[core] Move Map::Impl to its own def/impl files

include/mbgl/renderer/renderer_observer.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <exception>
 
 namespace mbgl {

src/core-files.json

@@ -46,6 +46,7 @@
         "src/mbgl/layout/symbol_layout.cpp",
         "src/mbgl/layout/symbol_projection.cpp",
         "src/mbgl/map/map.cpp",
+        "src/mbgl/map/map_impl.cpp",
         "src/mbgl/map/transform.cpp",
         "src/mbgl/map/transform_state.cpp",
         "src/mbgl/math/log2.cpp",
@@ -532,6 +533,7 @@
         "mbgl/layout/symbol_instance.hpp": "src/mbgl/layout/symbol_instance.hpp",
         "mbgl/layout/symbol_layout.hpp": "src/mbgl/layout/symbol_layout.hpp",
         "mbgl/layout/symbol_projection.hpp": "src/mbgl/layout/symbol_projection.hpp",
+        "mbgl/map/map_impl.hpp": "src/mbgl/map/map_impl.hpp",
         "mbgl/map/transform.hpp": "src/mbgl/map/transform.hpp",
         "mbgl/map/transform_state.hpp": "src/mbgl/map/transform_state.hpp",
         "mbgl/map/zoom_history.hpp": "src/mbgl/map/zoom_history.hpp",

src/mbgl/map/map.cpp

@@ -1,7 +1,7 @@
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/map_impl.hpp>
 #include <mbgl/map/camera.hpp>
 #include <mbgl/map/transform.hpp>
-#include <mbgl/map/transform_state.hpp>
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/layermanager/layer_manager.hpp>
 #include <mbgl/style/style_impl.hpp>
@@ -20,77 +20,13 @@
 #include <mbgl/actor/scheduler.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/math/log2.hpp>
+
 #include <utility>
 
 namespace mbgl {
 
 using namespace style;
 
-struct StillImageRequest {
-    StillImageRequest(Map::StillImageCallback&& callback_)
-        : callback(std::move(callback_)) {
-    }
-
-    Map::StillImageCallback callback;
-};
-
-class Map::Impl : public style::Observer,
-                  public RendererObserver {
-public:
-    Impl(Map&,
-         RendererFrontend&,
-         MapObserver&,
-         float pixelRatio,
-         FileSource&,
-         Scheduler&,
-         MapMode,
-         ConstrainMode,
-         ViewportMode,
-         bool);
-
-    ~Impl();
-
-    // StyleObserver
-    void onSourceChanged(style::Source&) override;
-    void onUpdate() override;
-    void onStyleLoading() override;
-    void onStyleLoaded() override;
-    void onStyleError(std::exception_ptr) override;
-
-    // RendererObserver
-    void onInvalidate() override;
-    void onResourceError(std::exception_ptr) override;
-    void onWillStartRenderingFrame() override;
-    void onDidFinishRenderingFrame(RenderMode, bool) override;
-    void onWillStartRenderingMap() override;
-    void onDidFinishRenderingMap() override;
-
-    Map& map;
-    MapObserver& observer;
-    RendererFrontend& rendererFrontend;
-    FileSource& fileSource;
-    Scheduler& scheduler;
-
-    Transform transform;
-
-    const MapMode mode;
-    const float pixelRatio;
-    const bool crossSourceCollisions;
-
-    MapDebugOptions debugOptions { MapDebugOptions::NoDebug };
-
-    std::unique_ptr<Style> style;
-    AnnotationManager annotationManager;
-
-    bool cameraMutated = false;
-
-    uint8_t prefetchZoomDelta = util::DEFAULT_PREFETCH_ZOOM_DELTA;
-
-    bool loading = false;
-    bool rendererFullyLoaded;
-    std::unique_ptr<StillImageRequest> stillImageRequest;
-};
-
 Map::Map(RendererFrontend& rendererFrontend,
          MapObserver& mapObserver,
          const Size size,
@@ -104,49 +40,14 @@ Map::Map(RendererFrontend& rendererFrontend,
     : impl(std::make_unique<Impl>(*this,
                                   rendererFrontend,
                                   mapObserver,
-                                  pixelRatio,
                                   fileSource,
                                   scheduler,
+                                  size,
+                                  pixelRatio,
                                   mapMode,
                                   constrainMode,
                                   viewportMode,
-                                  crossSourceCollisions)) {
-    impl->transform.resize(size);
-}
-
-Map::Impl::Impl(Map& map_,
-                RendererFrontend& frontend,
-                MapObserver& mapObserver,
-                float pixelRatio_,
-                FileSource& fileSource_,
-                Scheduler& scheduler_,
-                MapMode mode_,
-                ConstrainMode constrainMode_,
-                ViewportMode viewportMode_,
-                bool crossSourceCollisions_)
-    : map(map_),
-      observer(mapObserver),
-      rendererFrontend(frontend),
-      fileSource(fileSource_),
-      scheduler(scheduler_),
-      transform(observer,
-                constrainMode_,
-                viewportMode_),
-      mode(mode_),
-      pixelRatio(pixelRatio_),
-      crossSourceCollisions(crossSourceCollisions_),
-      style(std::make_unique<Style>(scheduler, fileSource, pixelRatio)),
-      annotationManager(*style) {
-
-    style->impl->setObserver(this);
-    rendererFrontend.setObserver(*this);
-}
-
-Map::Impl::~Impl() {
-    // Explicitly reset the RendererFrontend first to ensure it releases
-    // All shared resources (AnnotationManager)
-    rendererFrontend.reset();
-};
+                                  crossSourceCollisions)) {}
 
 Map::~Map() = default;
 
@@ -187,47 +88,6 @@ void Map::triggerRepaint() {
     impl->onUpdate();
 }
 
-#pragma mark - Map::Impl RendererObserver
-
-void Map::Impl::onWillStartRenderingMap() {
-    if (mode == MapMode::Continuous) {
-        observer.onWillStartRenderingMap();
-    }
-}
-
-void Map::Impl::onWillStartRenderingFrame() {
-    if (mode == MapMode::Continuous) {
-        observer.onWillStartRenderingFrame();
-    }
-}
-
-void Map::Impl::onDidFinishRenderingFrame(RenderMode renderMode, bool needsRepaint) {
-    rendererFullyLoaded = renderMode == RenderMode::Full;
-
-    if (mode == MapMode::Continuous) {
-        observer.onDidFinishRenderingFrame(MapObserver::RenderMode(renderMode));
-
-        if (needsRepaint || transform.inTransition()) {
-            onUpdate();
-        } else if (rendererFullyLoaded) {
-            observer.onDidBecomeIdle();
-        }
-    } else if (stillImageRequest && rendererFullyLoaded) {
-        auto request = std::move(stillImageRequest);
-        request->callback(nullptr);
-    }
-}
-
-void Map::Impl::onDidFinishRenderingMap() {
-    if (mode == MapMode::Continuous && loading) {
-        observer.onDidFinishRenderingMap(MapObserver::RenderMode::Full);
-        if (loading) {
-            loading = false;
-            observer.onDidFinishLoadingMap();
-        }
-    }
-};
-
 #pragma mark - Style
 
 style::Style& Map::getStyle() {
@@ -730,74 +590,6 @@ bool Map::isFullyLoaded() const {
     return impl->style->impl->isLoaded() && impl->rendererFullyLoaded;
 }
 
-void Map::Impl::onSourceChanged(style::Source& source) {
-    observer.onSourceChanged(source);
-}
-
-void Map::Impl::onInvalidate() {
-    onUpdate();
-}
-
-void Map::Impl::onUpdate() {
-    // Don't load/render anything in still mode until explicitly requested.
-    if (mode != MapMode::Continuous && !stillImageRequest) {
-        return;
-    }
-
-    TimePoint timePoint = mode == MapMode::Continuous ? Clock::now() : Clock::time_point::max();
-
-    transform.updateTransitions(timePoint);
-
-    UpdateParameters params = {
-        style->impl->isLoaded(),
-        mode,
-        pixelRatio,
-        debugOptions,
-        timePoint,
-        transform.getState(),
-        style->impl->getGlyphURL(),
-        style->impl->spriteLoaded,
-        style->impl->getTransitionOptions(),
-        style->impl->getLight()->impl,
-        style->impl->getImageImpls(),
-        style->impl->getSourceImpls(),
-        style->impl->getLayerImpls(),
-        annotationManager,
-        prefetchZoomDelta,
-        bool(stillImageRequest),
-        crossSourceCollisions
-    };
-
-    rendererFrontend.update(std::make_shared<UpdateParameters>(std::move(params)));
-}
-
-void Map::Impl::onStyleLoading() {
-    loading = true;
-    rendererFullyLoaded = false;
-    observer.onWillStartLoadingMap();
-}
-
-void Map::Impl::onStyleLoaded() {
-    if (!cameraMutated) {
-        map.jumpTo(style->getDefaultCamera());
-    }
-    if (LayerManager::annotationsEnabled) {
-        annotationManager.onStyleLoaded();
-    }
-    observer.onDidFinishLoadingStyle();
-}
-
-void Map::Impl::onStyleError(std::exception_ptr error) {
-    observer.onDidFailLoadingMap(error);
-}
-
-void Map::Impl::onResourceError(std::exception_ptr error) {
-    if (mode != MapMode::Continuous && stillImageRequest) {
-        auto request = std::move(stillImageRequest);
-        request->callback(error);
-    }
-}
-
 void Map::dumpDebugLogs() const {
     Log::Info(Event::General, "--------------------------------------------------------------------------------");
     impl->style->impl->dumpDebugLogs();

src/mbgl/map/map_impl.cpp

@@ -0,0 +1,155 @@
+#include <mbgl/layermanager/layer_manager.hpp>
+#include <mbgl/map/map_impl.hpp>
+#include <mbgl/renderer/update_parameters.hpp>
+#include <mbgl/style/style_impl.hpp>
+
+namespace mbgl {
+
+Map::Impl::Impl(Map& map_,
+                RendererFrontend& frontend,
+                MapObserver& mapObserver,
+                FileSource& fileSource_,
+                Scheduler& scheduler_,
+                Size size_,
+                float pixelRatio_,
+                MapMode mode_,
+                ConstrainMode constrainMode_,
+                ViewportMode viewportMode_,
+                bool crossSourceCollisions_)
+    : map(map_),
+      observer(mapObserver),
+      rendererFrontend(frontend),
+      fileSource(fileSource_),
+      scheduler(scheduler_),
+      transform(observer,
+                constrainMode_,
+                viewportMode_),
+      mode(mode_),
+      pixelRatio(pixelRatio_),
+      crossSourceCollisions(crossSourceCollisions_),
+      style(std::make_unique<style::Style>(scheduler, fileSource, pixelRatio)),
+      annotationManager(*style) {
+
+    style->impl->setObserver(this);
+    rendererFrontend.setObserver(*this);
+    transform.resize(size_);
+}
+
+Map::Impl::~Impl() {
+    // Explicitly reset the RendererFrontend first to ensure it releases
+    // All shared resources (AnnotationManager)
+    rendererFrontend.reset();
+};
+
+#pragma mark - Map::Impl StyleObserver
+
+void Map::Impl::onSourceChanged(style::Source& source) {
+    observer.onSourceChanged(source);
+}
+
+void Map::Impl::onUpdate() {
+    // Don't load/render anything in still mode until explicitly requested.
+    if (mode != MapMode::Continuous && !stillImageRequest) {
+        return;
+    }
+
+    TimePoint timePoint = mode == MapMode::Continuous ? Clock::now() : Clock::time_point::max();
+
+    transform.updateTransitions(timePoint);
+
+    UpdateParameters params = {
+        style->impl->isLoaded(),
+        mode,
+        pixelRatio,
+        debugOptions,
+        timePoint,
+        transform.getState(),
+        style->impl->getGlyphURL(),
+        style->impl->spriteLoaded,
+        style->impl->getTransitionOptions(),
+        style->impl->getLight()->impl,
+        style->impl->getImageImpls(),
+        style->impl->getSourceImpls(),
+        style->impl->getLayerImpls(),
+        annotationManager,
+        prefetchZoomDelta,
+        bool(stillImageRequest),
+        crossSourceCollisions
+    };
+
+    rendererFrontend.update(std::make_shared<UpdateParameters>(std::move(params)));
+}
+
+void Map::Impl::onStyleLoading() {
+    loading = true;
+    rendererFullyLoaded = false;
+    observer.onWillStartLoadingMap();
+}
+
+void Map::Impl::onStyleLoaded() {
+    if (!cameraMutated) {
+        map.jumpTo(style->getDefaultCamera());
+    }
+    if (LayerManager::annotationsEnabled) {
+        annotationManager.onStyleLoaded();
+    }
+    observer.onDidFinishLoadingStyle();
+}
+
+void Map::Impl::onStyleError(std::exception_ptr error) {
+    observer.onDidFailLoadingMap(error);
+}
+
+#pragma mark - Map::Impl RendererObserver
+
+void Map::Impl::onInvalidate() {
+    onUpdate();
+}
+
+void Map::Impl::onResourceError(std::exception_ptr error) {
+    if (mode != MapMode::Continuous && stillImageRequest) {
+        auto request = std::move(stillImageRequest);
+        request->callback(error);
+    }
+}
+
+void Map::Impl::onWillStartRenderingFrame() {
+    if (mode == MapMode::Continuous) {
+        observer.onWillStartRenderingFrame();
+    }
+}
+
+void Map::Impl::onDidFinishRenderingFrame(RenderMode renderMode, bool needsRepaint) {
+    rendererFullyLoaded = renderMode == RenderMode::Full;
+
+    if (mode == MapMode::Continuous) {
+        observer.onDidFinishRenderingFrame(MapObserver::RenderMode(renderMode));
+
+        if (needsRepaint || transform.inTransition()) {
+            onUpdate();
+        } else if (rendererFullyLoaded) {
+            observer.onDidBecomeIdle();
+        }
+    } else if (stillImageRequest && rendererFullyLoaded) {
+        auto request = std::move(stillImageRequest);
+        request->callback(nullptr);
+    }
+}
+
+void Map::Impl::onWillStartRenderingMap() {
+    if (mode == MapMode::Continuous) {
+        observer.onWillStartRenderingMap();
+    }
+}
+
+void Map::Impl::onDidFinishRenderingMap() {
+    if (mode == MapMode::Continuous && loading) {
+        observer.onDidFinishRenderingMap(MapObserver::RenderMode::Full);
+        if (loading) {
+            loading = false;
+            observer.onDidFinishLoadingMap();
+        }
+    }
+};
+
+} // namespace mbgl

src/mbgl/map/map_impl.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/annotation/annotation_manager.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/map/map_observer.hpp>
+#include <mbgl/map/mode.hpp>
+#include <mbgl/map/transform.hpp>
+#include <mbgl/renderer/renderer_frontend.hpp>
+#include <mbgl/renderer/renderer_observer.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/style/observer.hpp>
+#include <mbgl/style/source.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/util/size.hpp>
+
+namespace mbgl {
+
+struct StillImageRequest {
+    StillImageRequest(Map::StillImageCallback&& callback_)
+        : callback(std::move(callback_)) {
+    }
+
+    Map::StillImageCallback callback;
+};
+
+class Map::Impl : public style::Observer, public RendererObserver {
+public:
+    Impl(Map&,
+         RendererFrontend&,
+         MapObserver&,
+         FileSource&,
+         Scheduler&,
+
+         Size size,
+         float pixelRatio,
+
+         MapMode,
+         ConstrainMode,
+         ViewportMode,
+         bool crossSourceCollisions);
+
+    ~Impl() final;
+
+    // StyleObserver
+    void onSourceChanged(style::Source&) final;
+    void onUpdate() final;
+    void onStyleLoading() final;
+    void onStyleLoaded() final;
+    void onStyleError(std::exception_ptr) final;
+
+    // RendererObserver
+    void onInvalidate() final;
+    void onResourceError(std::exception_ptr) final;
+    void onWillStartRenderingFrame() final;
+    void onDidFinishRenderingFrame(RenderMode, bool) final;
+    void onWillStartRenderingMap() final;
+    void onDidFinishRenderingMap() final;
+
+    Map& map;
+    MapObserver& observer;
+    RendererFrontend& rendererFrontend;
+    FileSource& fileSource;
+    Scheduler& scheduler;
+
+    Transform transform;
+
+    const MapMode mode;
+    const float pixelRatio;
+    const bool crossSourceCollisions;
+
+    MapDebugOptions debugOptions { MapDebugOptions::NoDebug };
+
+    std::unique_ptr<style::Style> style;
+    AnnotationManager annotationManager;
+
+    bool cameraMutated = false;
+
+    uint8_t prefetchZoomDelta = util::DEFAULT_PREFETCH_ZOOM_DELTA;
+
+    bool loading = false;
+    bool rendererFullyLoaded;
+    std::unique_ptr<StillImageRequest> stillImageRequest;
+};
+
+} // namespace mbgl