separate camera renderUpdate - this allows to process cameras in arbi…

…trary order

browser/src/vts-browser-desktop/mainWindow.cpp

@@ -335,7 +335,8 @@ void MainWindow::run()
         try
         {
             updateWindowSize();
-            map->renderTick(timingTotalFrame * 1e-3);
+            map->renderUpdate(timingTotalFrame * 1e-3);
+            camera->renderUpdate();
         }
         catch (const vts::MapconfigException &e)
         {

browser/src/vts-browser-minimal-c/main.c

@@ -189,15 +189,16 @@ int main()
         }
 
         // update downloads
-        vtsMapDataTick(map);
+        vtsMapDataUpdate(map);
         check();
 
         // check if the window has been resized
         updateResolution();
 
         // update navigation etc.
         uint32 currentRenderTime = SDL_GetTicks();
-        vtsMapRenderTick(map, (currentRenderTime - lastRenderTime) * 1e-3);
+        vtsMapRenderUpdate(map, (currentRenderTime - lastRenderTime) * 1e-3);
+        vtsCameraRenderUpdate(cam);
         check();
         lastRenderTime = currentRenderTime;
 

browser/src/vts-browser-minimal-cpp/main.cpp

@@ -158,14 +158,15 @@ int main(int, char *[])
         }
 
         // update downloads
-        map->dataTick();
+        map->dataUpdate();
 
         // check if window size has changed
         updateResolution();
 
         // update navigation etc.
         uint32 currentRenderTime = SDL_GetTicks();
-        map->renderTick((currentRenderTime - lastRenderTime) * 1e-3);
+        map->renderUpdate((currentRenderTime - lastRenderTime) * 1e-3);
+        cam->renderUpdate();
         lastRenderTime = currentRenderTime;
 
         // actually render the map

browser/src/vts-browser-minimal-cs/Window.cs

@@ -76,9 +76,10 @@ public void Draw(object sender, EventArgs args)
             if (c.Width <= 0 || c.Height <= 0)
                 return;
 
+            map.DataUpdate();
+            map.RenderUpdate(0);
             cam.SetViewportSize((uint)c.Width, (uint)c.Height);
-            map.DataTick();
-            map.RenderTick(0);
+            cam.RenderUpdate();
 
             RenderOptions ro = renderer.Options;
             ro.width = (uint)c.Width;

browser/src/vts-browser-two-cameras/main.cpp

@@ -141,8 +141,10 @@ int main(int, char *[])
         }
 
         uint32 currentRenderTime = SDL_GetTicks();
-        map->dataTick();
-        map->renderTick((currentRenderTime - lastRenderTime) * 1e-3);
+        map->dataUpdate();
+        map->renderUpdate((currentRenderTime - lastRenderTime) * 1e-3);
+        cam1->renderUpdate();
+        cam2->renderUpdate();
         lastRenderTime = currentRenderTime;
 
         auto &ro = render.options();

browser/src/vts-libbrowser-cs/Camera.cs

@@ -141,6 +141,12 @@ public void SetOptions(string json)
             Util.CheckInterop();
         }
 
+        public void RenderUpdate()
+        {
+            BrowserInterop.vtsCameraRenderUpdate(Handle);
+            Util.CheckInterop();
+        }
+
         public void Dispose()
         {
             Dispose(true);

browser/src/vts-libbrowser-cs/Interop.cs

@@ -101,6 +101,9 @@ public static class BrowserInterop
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
 public static extern void vtsCameraSuggestedNearFar(IntPtr cam, ref double near_, ref double far_);
 
+[DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
+public static extern void vtsCameraRenderUpdate(IntPtr cam);
+
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
 public static extern IntPtr vtsCameraGetCredits(IntPtr cam);
 
@@ -262,7 +265,7 @@ public static class BrowserInterop
 public static extern void vtsMapDataInitialize(IntPtr map);
 
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
-public static extern void vtsMapDataTick(IntPtr map);
+public static extern void vtsMapDataUpdate(IntPtr map);
 
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
 public static extern void vtsMapDataFinalize(IntPtr map);
@@ -274,7 +277,7 @@ public static class BrowserInterop
 public static extern void vtsMapRenderInitialize(IntPtr map);
 
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
-public static extern void vtsMapRenderTick(IntPtr map, double elapsedTime);
+public static extern void vtsMapRenderUpdate(IntPtr map, double elapsedTime);
 
 [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
 public static extern void vtsMapRenderFinalize(IntPtr map);

browser/src/vts-libbrowser-cs/Map.cs

@@ -120,9 +120,9 @@ public void DataInitialize()
             Util.CheckInterop();
         }
 
-        public void DataTick()
+        public void DataUpdate()
         {
-            BrowserInterop.vtsMapDataTick(Handle);
+            BrowserInterop.vtsMapDataUpdate(Handle);
             Util.CheckInterop();
         }
 
@@ -144,9 +144,9 @@ public void RenderInitialize()
             Util.CheckInterop();
         }
 
-        public void RenderTick(double elapsedTime)
+        public void RenderUpdate(double elapsedTime)
         {
-            BrowserInterop.vtsMapRenderTick(Handle, elapsedTime);
+            BrowserInterop.vtsMapRenderUpdate(Handle, elapsedTime);
             Util.CheckInterop();
         }
 

browser/src/vts-libbrowser/camera/camera.cpp

@@ -466,10 +466,8 @@ bool operator == (const OldDraw &l, const OldDraw &r)
 }
 
 void CameraImpl::resolveBlending(TraverseNode *root,
-                        CameraMapLayer &layer, float elapsedTime)
+                        CameraMapLayer &layer)
 {
-    (void)elapsedTime;
-
     if (options.lodBlending == 0)
         return;
 
@@ -546,8 +544,15 @@ void CameraImpl::resolveBlending(TraverseNode *root,
     }
 }
 
-void CameraImpl::updateCamera(double elapsedTime)
+void CameraImpl::renderUpdate()
 {
+    clear();
+
+    if (!map->mapconfigReady)
+        return;
+
+    updateNavigation(navigation, map->lastElapsedFrameTime);
+
     if (windowWidth == 0 || windowHeight == 0)
         return;
 
@@ -613,7 +618,7 @@ void CameraImpl::updateCamera(double elapsedTime)
     {
         traverseRender(it->traverseRoot.get());
         // resolve blending
-        resolveBlending(it->traverseRoot.get(), layers[it], elapsedTime);
+        resolveBlending(it->traverseRoot.get(), layers[it]);
         // resolve subtile merging
         for (auto &os : opaqueSubtiles)
             os.second.resolve(os.first, this);

browser/src/vts-libbrowser/camera/camera.hpp

@@ -162,12 +162,14 @@ class CameraImpl
     void gridPreloadProcess(TraverseNode *trav,
                             const std::vector<TileId> &requests);
     void resolveBlending(TraverseNode *root,
-                CameraMapLayer &layer, float elapsedTime);
+                CameraMapLayer &layer);
     void sortOpaqueFrontToBack();
-    void updateCamera(double elapsedTime);
+    void renderUpdate();
     void suggestedNearFar(double &near_, double &far_);
 };
 
+void updateNavigation(std::weak_ptr<NavigationImpl> nav, double elapsedTime);
+
 } // namespace vts
 
 #endif

browser/src/vts-libbrowser/camera/cameraApi.cpp

@@ -118,6 +118,11 @@ void Camera::suggestedNearFar(double &near_, double &far_)
         near_ = far_ = 0;
 }
 
+void Camera::renderUpdate()
+{
+    impl->renderUpdate();
+}
+
 CameraStatistics &Camera::statistics()
 {
     return impl->statistics;

browser/src/vts-libbrowser/include/vts-browser/camera.h

@@ -53,6 +53,7 @@ VTS_API void vtsCameraGetViewMatrix(vtsHCamera cam, double view[16]);
 VTS_API void vtsCameraGetProjMatrix(vtsHCamera cam, double proj[16]);
 VTS_API void vtsCameraSuggestedNearFar(vtsHCamera cam,
                     double *near_, double *far_);
+VTS_API void vtsCameraRenderUpdate(vtsHCamera cam);
 
 // credits
 VTS_API const char *vtsCameraGetCredits(vtsHCamera cam);

browser/src/vts-libbrowser/include/vts-browser/camera.hpp

@@ -59,6 +59,8 @@ class VTS_API Camera
 
     void suggestedNearFar(double &near_, double &far_);
 
+    void renderUpdate();
+
     class CameraCredits &credits();
     class CameraDraws &draws();
     class CameraOptions &options();

browser/src/vts-libbrowser/include/vts-browser/map.h

@@ -55,13 +55,13 @@ VTS_API double vtsMapGetRenderProgress(vtsHMap map);
 
 // data processing (may be run on a dedicated thread)
 VTS_API void vtsMapDataInitialize(vtsHMap map);
-VTS_API void vtsMapDataTick(vtsHMap map);
+VTS_API void vtsMapDataUpdate(vtsHMap map);
 VTS_API void vtsMapDataFinalize(vtsHMap map);
 VTS_API void vtsMapDataAllRun(vtsHMap map);
 
 // rendering
 VTS_API void vtsMapRenderInitialize(vtsHMap map);
-VTS_API void vtsMapRenderTick(vtsHMap map, double elapsedTime); // seconds since last call
+VTS_API void vtsMapRenderUpdate(vtsHMap map, double elapsedTime); // seconds since last call
 VTS_API void vtsMapRenderFinalize(vtsHMap map);
 
 // options and statistics

browser/src/vts-libbrowser/include/vts-browser/map.hpp

@@ -80,7 +80,7 @@ class VTS_API Map
     // dataTick does at most MapOptions.maxResourceProcessesPerTick
     //   operations and returns
     // you should call it periodically
-    void dataTick();
+    void dataUpdate();
     void dataFinalize();
 
     // blocking alternative to:
@@ -93,7 +93,7 @@ class VTS_API Map
     void dataAllRun();
 
     void renderInitialize();
-    void renderTick(double elapsedTime); // seconds since last call
+    void renderUpdate(double elapsedTime); // seconds since last call
     void renderFinalize();
 
     // create new camera

browser/src/vts-libbrowser/map.cpp

@@ -27,18 +27,117 @@
 #include <utility/uri.hpp>
 
 #include "map.hpp"
+#include "navigation/navigation.hpp"
 
 namespace vts
 {
 
 void MapImpl::renderInitialize()
 {
-    LOG(info3) << "Render initialize";
+    LOG(info2) << "Render initialize";
 }
 
 void MapImpl::renderFinalize()
 {
-    LOG(info3) << "Render finalize";
+    LOG(info2) << "Render finalize";
+}
+
+void MapImpl::renderUpdate(double elapsedTime)
+{
+    lastElapsedFrameTime = elapsedTime;
+
+    if (!prerequisitesCheck())
+        return;
+
+    assert(!resources.auth || *resources.auth);
+    assert(mapconfig && *mapconfig);
+    assert(convertor);
+    assert(!layers.empty());
+    assert(layers[0]->traverseRoot);
+
+    updateSearch();
+
+    cameras.erase(std::remove_if(cameras.begin(), cameras.end(),
+        [&](std::weak_ptr<CameraImpl> &camera) {
+        return !!camera.lock();
+    }), cameras.end());
+
+    for (auto &it : layers)
+        traverseClearing(it->traverseRoot.get());
+
+    if (mapconfig->atmosphereDensityTexture)
+        updateAtmosphereDensity();
+}
+
+void MapImpl::initializeNavigation()
+{
+    for (auto &camera : cameras)
+    {
+        auto cam = camera.lock();
+        if (cam)
+        {
+            auto nav = cam->navigation.lock();
+            if (nav)
+                nav->initialize();
+        }
+    }
+}
+
+void MapImpl::purgeMapconfig()
+{
+    LOG(info2) << "Purge mapconfig";
+
+    if (resources.auth)
+        resources.auth->forceRedownload();
+    resources.auth.reset();
+    if (mapconfig)
+        mapconfig->forceRedownload();
+    mapconfig.reset();
+    mapconfigAvailable = false;
+
+    credits.purge();
+    resources.searchTasks.clear();
+    convertor.reset();
+    body = MapCelestialBody();
+    purgeViewCache();
+
+    for (auto &camera : cameras)
+    {
+        auto cam = camera.lock();
+        if (cam)
+        {
+            auto nav = cam->navigation.lock();
+            if (nav)
+            {
+                nav->autoRotation = 0;
+                nav->resetNavigationMode();
+                nav->lastPositionAltitude.reset();
+                nav->positionAltitudeReset.reset();
+            }
+        }
+    }
+}
+
+void MapImpl::purgeViewCache()
+{
+    LOG(info2) << "Purge view cache";
+
+    if (mapconfig)
+        mapconfig->consolidateView();
+    mapconfigReady = false;
+    mapconfigView = "";
+    layers.clear();
+
+    for (auto &camera : cameras)
+    {
+        auto cam = camera.lock();
+        if (cam)
+        {
+            cam->statistics = CameraStatistics();
+            cam->draws = CameraDraws();
+            cam->credits = CameraCredits();
+        }
+    }
 }
 
 void MapImpl::setMapconfigPath(const std::string &mapconfigPath,
@@ -121,7 +220,7 @@ bool MapImpl::prerequisitesCheck()
             return false;
     }
 
-    LOG(info2) << "Mapconfig is ready.";
+    LOG(info3) << "Mapconfig is ready.";
     mapconfigReady = true;
     if (callbacks.mapconfigReady)
         callbacks.mapconfigReady(); // this may change mapconfigReady