bench/src/benchStyleContext.cpp

@@ -32,30 +32,19 @@ const char tile_file[] = "res/tile.mvt";
 std::shared_ptr<Scene> scene;
 std::shared_ptr<TileSource> source;
 std::shared_ptr<TileData> tileData;
-
-std::unique_ptr<MockPlatform> platform = std::make_unique<MockPlatform>();
+MockPlatform platform;
 
 void globalSetup() {
     static std::atomic<bool> initialized{false};
     if (initialized.exchange(true)) { return; }
 
-    Url sceneUrl(scene_file);
-    platform->putMockUrlContents(sceneUrl, MockPlatform::getBytesFromFile(scene_file));
-    scene = std::make_shared<Scene>(*platform, sceneUrl);
-    Importer importer(scene);
-    try {
-        scene->config() = importer.applySceneImports(*platform);
-    }
-    catch (const YAML::ParserException& e) {
-        LOGE("Parsing scene config '%s'", e.what());
-        exit(-1);
-    }
-    if (!scene->config()) {
-        LOGE("Invalid scene file '%s'", scene_file);
-        exit(-1);
-    }
-    SceneLoader::applyConfig(*platform, scene);
-    scene->fontContext()->loadFonts();
+    SceneOptions sceneOptions{platform.resolveUrl(Url(scene_file))};
+    sceneOptions.numTileWorkers = 0;
+    sceneOptions.prefetchTiles = false;
+
+    scene = std::make_shared<Scene>(platform, std::move(sceneOptions));
+    if (!scene->load()) { exit(-1); }
+
     for (auto& s : scene->tileSources()) {
         source = s;
         if (source->generateGeometry()) { break; }

bench/src/benchTileBuilder.cpp

@@ -32,31 +32,18 @@ const char tile_file[] = "res/tile.mvt";
 std::shared_ptr<Scene> scene;
 std::shared_ptr<TileSource> source;
 std::shared_ptr<TileData> tileData;
-
-std::unique_ptr<MockPlatform> platform = std::make_unique<MockPlatform>();
+MockPlatform platform;
 
 void globalSetup() {
     static std::atomic<bool> initialized{false};
     if (initialized.exchange(true)) { return; }
 
-    Url sceneUrl(scene_file);
-    platform->putMockUrlContents(sceneUrl, MockPlatform::getBytesFromFile(scene_file));
+    SceneOptions sceneOptions{platform.resolveUrl(Url(scene_file))};
+    sceneOptions.numTileWorkers = 0;
+    sceneOptions.prefetchTiles = false;
 
-    scene = std::make_shared<Scene>(*platform, sceneUrl);
-    Importer importer(scene);
-    try {
-        scene->config() = importer.applySceneImports(*platform);
-    }
-    catch (const YAML::ParserException& e) {
-        LOGE("Parsing scene config '%s'", e.what());
-        exit(-1);
-    }
-    if (!scene->config()) {
-        LOGE("Invalid scene file '%s'", scene_file);
-        exit(-1);
-    }
-    SceneLoader::applyConfig(*platform, scene);
-    scene->fontContext()->loadFonts();
+    scene = std::make_shared<Scene>(platform, std::move(sceneOptions));
+    if (!scene->load()) { exit(-1); }
 
     for (auto& s : scene->tileSources()) {
         source = s;
@@ -82,7 +69,8 @@ class TileBuilderFixture : public benchmark::Fixture {
     std::shared_ptr<Tile> result;
     void SetUp(const ::benchmark::State& state) override {
         globalSetup();
-        tileBuilder = std::make_unique<TileBuilder>(scene, new StyleContext());
+        tileBuilder = std::make_unique<TileBuilder>(*scene, new StyleContext());
+        tileBuilder->init();
     }
     void TearDown(const ::benchmark::State& state) override {
         result.reset();

core/CMakeLists.txt

@@ -74,8 +74,8 @@ add_library(tangram-core
   src/labels/labelProperty.cpp
   src/labels/labelSet.h
   src/labels/labelSet.cpp
-  src/labels/labels.h
-  src/labels/labels.cpp
+  src/labels/labelManager.h
+  src/labels/labelManager.cpp
   src/labels/spriteLabel.h
   src/labels/spriteLabel.cpp
   src/labels/textLabel.h

core/include/tangram/log.h

@@ -66,3 +66,52 @@ do { Tangram::logMsg("ERROR %s:%d: " fmt "\n", __FILENAME__, __LINE__, ## __VA_A
 #define LOG(fmt, ...)
 #define LOGN(fmt, ...)
 #endif
+
+#if 0
+#include <mutex>
+#include <chrono>
+
+extern std::chrono::time_point<std::chrono::system_clock> tangram_log_time_start, tangram_log_time_last;
+extern std::mutex tangram_log_time_mutex;
+
+#define LOGTIME(fmt, ...) do { \
+    int l = strlen( __FILENAME__);  \
+    Tangram::logMsg("TIME %-18.*s " fmt "\n",                            \
+                    l > 4 ? l-4 : l, __FILENAME__, ##__VA_ARGS__); } while (0)
+
+// Overall timing init/reset
+#define LOGTOInit() do {                                                \
+        std::lock_guard<std::mutex> lock(tangram_log_time_mutex);       \
+        tangram_log_time_last = tangram_log_time_start = std::chrono::system_clock::now(); } while(0)
+
+// Overall timing
+#define LOGTO(fmt, ...) do {                                            \
+        std::lock_guard<std::mutex> lock(tangram_log_time_mutex);       \
+        std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now(); \
+        std::chrono::duration<double> t1 = now - tangram_log_time_start; \
+        std::chrono::duration<double> t2 = now - tangram_log_time_last; \
+        tangram_log_time_last = now;                                    \
+        LOGTIME("%7.2f %7.2f " fmt, t1.count()*1000.f, t2.count()*1000.f, ## __VA_ARGS__); } while(0)
+
+// Local timing init
+#define LOGTInit(fmt, ...)                                              \
+    std::chrono::time_point<std::chrono::system_clock> _time_last, _time_start; \
+    std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now(); \
+    std::chrono::duration<double> t0 = now - tangram_log_time_start;    \
+    _time_start = _time_last = now;                                     \
+    LOGTIME("%7.2f                 " fmt, t0.count()*1000.f, ## __VA_ARGS__)
+
+// Local timing
+#define LOGT(fmt, ...) do {                                               \
+        std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now(); \
+        std::chrono::duration<double> t0 = now - tangram_log_time_start; \
+        std::chrono::duration<double> t1 = now - _time_start;           \
+        std::chrono::duration<double> t2 = now - _time_last;            \
+        _time_last = now;                                               \
+        LOGTIME("%7.2f %7.2f %7.2f " fmt, t0.count()*1000.f, t1.count()*1000.f, t2.count()*1000.f, ## __VA_ARGS__); } while(0)
+#else
+#define LOGT(...)
+#define LOGTInit(...)
+#define LOGTOInit()
+#define LOGTO(...)
+#endif

core/include/tangram/map.h

@@ -2,6 +2,7 @@
 
 #include "data/properties.h"
 #include "util/types.h"
+#include "sceneOptions.h"
 
 #include <array>
 #include <functional>
@@ -14,6 +15,7 @@ namespace Tangram {
 class Platform;
 class TileSource;
 class Scene;
+class SceneOptions;
 
 enum LabelType {
     icon,
@@ -58,13 +60,6 @@ struct MarkerPickResult {
 // Returns a pointer to the selected marker pick result or null, only valid on the callback scope
 using MarkerPickCallback = std::function<void(const MarkerPickResult*)>;
 
-struct SceneUpdate {
-    std::string path;
-    std::string value;
-    SceneUpdate(std::string p, std::string v) : path(p), value(v) {}
-    SceneUpdate() {}
-};
-
 enum Error {
     none,
     scene_update_path_not_found,
@@ -114,15 +109,15 @@ struct EdgePadding {
 
 struct CameraUpdate {
     enum Flags {
-        SET_LNGLAT =      1 << 0,
-        SET_ZOOM =        1 << 1,
-        SET_ZOOM_BY =     1 << 2,
-        SET_ROTATION =    1 << 3,
-        SET_ROTATION_BY = 1 << 4,
-        SET_TILT =        1 << 5,
-        SET_TILT_BY =     1 << 6,
-        SET_BOUNDS =      1 << 7,
-        SET_CAMERA =      1 << 8,
+        set_lnglat =      1 << 0,
+        set_zoom =        1 << 1,
+        set_zoom_by =     1 << 2,
+        set_rotation =    1 << 3,
+        set_rotation_by = 1 << 4,
+        set_tilt =        1 << 5,
+        set_tilt_by =     1 << 6,
+        set_bounds =      1 << 7,
+        set_camera =      1 << 8,
     };
     int set = 0;
 
@@ -137,6 +132,26 @@ struct CameraUpdate {
     EdgePadding padding;
 };
 
+struct MapState {
+    enum Flags {
+        // NB: View is complete when no other flags are set.
+        view_complete =    0,
+        view_changing =    1 << 0,
+        labels_changing =  1 << 1,
+        tiles_loading =    1 << 3,
+        scene_loading =    1 << 4,
+        is_animating =     1 << 5,
+    };
+    uint32_t flags = 0;
+
+    bool viewComplete() { return flags == 0; }
+    bool viewChanging() { return flags & view_changing; }
+    bool labelsChanging() { return flags & labels_changing; }
+    bool tilesLoading() { return flags & tiles_loading; }
+    bool sceneLoading() { return flags & scene_loading; }
+    bool isAnimating() { return flags & is_animating; }
+};
+
 class Map {
 
 public:
@@ -145,31 +160,37 @@ class Map {
     explicit Map(std::unique_ptr<Platform> _platform);
     ~Map();
 
+
+    // Load the scene with the given SceneOptions
+    SceneID loadScene(SceneOptions&& _sceneOptions, bool _async = true);
+
+
+    // Load the scene at the given absolute file path synchronously
+    SceneID loadScene(const std::string& _scenePath, bool _useScenePosition = false,
+                      const std::vector<SceneUpdate>& _sceneUpdates = {}) {
+        return loadScene(SceneOptions{Url(_scenePath), _useScenePosition, _sceneUpdates}, false);
+
+    }
+
     // Load the scene at the given absolute file path asynchronously.
-    SceneID loadSceneAsync(const std::string& _scenePath,
-                           bool _useScenePosition = false,
-                           const std::vector<SceneUpdate>& _sceneUpdates = {});
+    SceneID loadSceneAsync(const std::string& _scenePath, bool _useScenePosition = false,
+                      const std::vector<SceneUpdate>& _sceneUpdates = {}) {
+        return loadScene(SceneOptions{Url(_scenePath), _useScenePosition, _sceneUpdates}, true);
+    }
 
     // Load the scene provided an explicit yaml scene string
     SceneID loadSceneYaml(const std::string& _yaml, const std::string& _resourceRoot,
                           bool _useScenePosition = false,
-                          const std::vector<SceneUpdate>& _sceneUpdates = {});
+                          const std::vector<SceneUpdate>& _sceneUpdates = {}) {
+        return loadScene(SceneOptions{_yaml, Url(_resourceRoot), _useScenePosition, _sceneUpdates}, false);
+    }
 
+    // Load the scene provided an explicit yaml scene string
     SceneID loadSceneYamlAsync(const std::string& _yaml, const std::string& _resourceRoot,
-                               bool _useScenePosition = false,
-                               const std::vector<SceneUpdate>& _sceneUpdates = {});
-
-    // Load the scene at the given absolute file path synchronously
-    SceneID loadScene(const std::string& _scenePath,
-                      bool _useScenePosition = false,
-                      const std::vector<SceneUpdate>& sceneUpdates = {});
-
-    // Request updates to the current scene configuration. This reloads the
-    // scene with the updated configuration.
-    // The SceneUpdate path is a series of yaml keys separated by a '.' and the
-    // value is a string of yaml to replace the current value at the given path
-    // in the scene.
-    SceneID updateSceneAsync(const std::vector<SceneUpdate>& sceneUpdates);
+                          bool _useScenePosition = false,
+                          const std::vector<SceneUpdate>& _sceneUpdates = {}) {
+        return loadScene(SceneOptions{_yaml, Url(_resourceRoot), _useScenePosition, _sceneUpdates}, true);
+    }
 
     // Set listener for scene load events. The callback receives the SceneID
     // of the loaded scene and SceneError in case loading was not successful.
@@ -178,22 +199,18 @@ class Map {
 
     void setCameraAnimationListener(CameraAnimationCallback _cb);
 
-    // Set an MBTiles SQLite database file for a DataSource in the scene.
-    void setMBTiles(const char* _dataSourceName, const char* _mbtilesFilePath);
-
     // Initialize graphics resources; OpenGL context must be created prior to calling this
     void setupGL();
 
     // Resize the map view to a new width and height (in pixels)
     void resize(int _newWidth, int _newHeight);
 
-    // Update the map state with the time interval since the last update, returns
-    // true when the current view is completely loaded (all tiles are available and
-    // no animation in progress)
-    bool update(float _dt);
+    // Update the map state with the time interval since the last update.
+    // Return MapState with flags set to determine whether the view is complete or changing.
+    MapState update(float _dt);
 
     // Render a new frame of the map view (if needed)
-    bool render();
+    void render();
 
     // Gets the viewport height in physical pixels (framebuffer size)
     int getViewportHeight();
@@ -301,7 +318,8 @@ class Map {
     // and removed, otherwise returns false.
     bool removeTileSource(TileSource& _source);
 
-    void clearTileSource(TileSource& _source, bool _data, bool _tiles);
+    // Returns true if the source was found and cleared, otherwise returns false.
+    bool clearTileSource(TileSource& _source, bool _data, bool _tiles);
 
     // Add a marker object to the map and return an ID for it; an ID of 0 indicates an invalid marker;
     // the marker will not be drawn until both styling and geometry are set using the functions below.
@@ -424,12 +442,6 @@ class Map {
 
     std::unique_ptr<Platform> platform;
 
-    SceneID loadSceneAsync(std::shared_ptr<Scene> _scene,
-                           const std::vector<SceneUpdate>& _sceneUpdates = {});
-
-    SceneID loadScene(std::shared_ptr<Scene> _scene,
-                      const std::vector<SceneUpdate>& _sceneUpdates = {});
-
 private:
 
     class Impl;