switched back to GUI-thread tile coverage and infoLayer merge calculations in TilingRenderPolicyMT

map/coverage_generator.cpp

@@ -7,25 +7,33 @@
 
 #include "../std/bind.hpp"
 
+ScreenCoverage::ScreenCoverage()
+{}
+
 struct unlock_synchronized
 {
-  TileCache * m_cache;
-  unlock_synchronized(TileCache * cache) : m_cache(cache)
+  TileCache * m_c;
+
+  unlock_synchronized(TileCache * c) : m_c(c)
   {}
 
   void operator()(Tile const * t)
   {
-    m_cache->lock();
-    m_cache->unlockTile(t->m_rectInfo);
-    m_cache->unlock();
+    m_c->lock();
+    m_c->unlockTile(t->m_rectInfo);
+    m_c->unlock();
   }
 };
 
-ScreenCoverage::ScreenCoverage()
-{}
-
 void ScreenCoverage::Clear()
 {
+  m_tileCache->lock();
+
+  for (unsigned i = 0; i < m_tiles.size(); ++i)
+    m_tileCache->unlockTile(m_tiles[i]->m_rectInfo);
+
+  m_tileCache->unlock();
+
   m_tiles.clear();
   m_infoLayer.clear();
 }
@@ -65,7 +73,6 @@ void CoverageGenerator::CoverageTask::execute(CoverageGenerator * generator)
 
       shared_ptr<Tile const> lockedTile = make_shared_ptr(tile, unlock_synchronized(&tileCache));
 
-
       generator->m_workCoverage->m_tiles.push_back(lockedTile);
       generator->m_workCoverage->m_infoLayer.merge(*tile->m_infoLayer.get(),
                                                     tile->m_tileScreen.PtoGMatrix() * generator->m_workCoverage->m_screen.GtoPMatrix());
@@ -84,9 +91,8 @@ void CoverageGenerator::CoverageTask::execute(CoverageGenerator * generator)
   }
 
   {
-    threads::MutexGuard g(generator->m_mutex);
-    LOG(LINFO, ("saving computed coverage into currentCoverage"));
-    *generator->m_currentCoverage = *generator->m_workCoverage;
+    threads::MutexGuard g(generator->Mutex());
+    swap(generator->m_currentCoverage, generator->m_workCoverage);
   }
 }
 

map/coverage_generator.hpp

@@ -16,15 +16,23 @@
 #include "../std/shared_ptr.hpp"
 
 class RenderQueue;
+class TileCache;
 
 /// holds the tile coverage for a specific screen
 struct ScreenCoverage
 {
+  TileCache * m_tileCache;
   ScreenBase m_screen;
   vector<shared_ptr<Tile const> > m_tiles;
   yg::InfoLayer m_infoLayer;
 
+  bool m_IsRendering; //< while this flag is set - the object shouldn't
+                      //be altered, 'cause GUI thread is rendering from it
+
   ScreenCoverage();
+
+  void Merge(Tiler::RectInfo const & rectInfo, Tile const & tile);
+  void Compute(ScreenBase const & screen);
   void Clear();
 };
 

map/tiling_render_policy_mt.cpp

@@ -21,12 +21,12 @@ TilingRenderPolicyMT::TilingRenderPolicyMT(shared_ptr<WindowHandle> const & wind
                   GetPlatform().MaxTilesCount(),
                   GetPlatform().CpuCores(),
                   bgColor()),
-//    m_tiler(GetPlatform().TileSize(),
-//            GetPlatform().ScaleEtalonSize())
-    m_coverageGenerator(GetPlatform().TileSize(),
-                        GetPlatform().ScaleEtalonSize(),
-                        renderFn,
-                        &m_renderQueue)
+    m_tiler(GetPlatform().TileSize(),
+            GetPlatform().ScaleEtalonSize())
+//    m_coverageGenerator(GetPlatform().TileSize(),
+//                        GetPlatform().ScaleEtalonSize(),
+//                        renderFn,
+//                        &m_renderQueue)
 {
   m_renderQueue.AddWindowHandle(windowHandle);
 }
@@ -36,7 +36,7 @@ void TilingRenderPolicyMT::Initialize(shared_ptr<yg::gl::RenderContext> const &
 {
   RenderPolicy::Initialize(primaryContext, resourceManager);
   m_renderQueue.Initialize(primaryContext, resourceManager, GetPlatform().VisualScale());
-  m_coverageGenerator.Initialize();
+//  m_coverageGenerator.Initialize();
 }
 
 void TilingRenderPolicyMT::OnSize(int /*w*/, int /*h*/)
@@ -48,7 +48,7 @@ void TilingRenderPolicyMT::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBas
   DrawerYG * pDrawer = e->drawer().get();
   pDrawer->screen()->clear(bgColor());
 
-  m_coverageGenerator.AddCoverageTask(currentScreen);
+/*  m_coverageGenerator.AddCoverageTask(currentScreen);
 
   ScreenCoverage coverage;
 
@@ -75,8 +75,8 @@ void TilingRenderPolicyMT::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBas
   coverage.m_infoLayer.draw(pDrawer->screen().get(),
                             coverage.m_screen.PtoGMatrix() * currentScreen.GtoPMatrix());
 
-  coverage.Clear();
-/*
+  coverage.Clear();*/
+
   m_infoLayer.clear();
 
   m_tiler.seed(currentScreen,
@@ -86,13 +86,15 @@ void TilingRenderPolicyMT::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBas
   {
     Tiler::RectInfo ri = m_tiler.nextTile();
 
-    m_renderQueue.TileCache().lock();
+    TileCache & tileCache = m_renderQueue.GetTileCache();
 
-    if (m_renderQueue.TileCache().hasTile(ri))
+    tileCache.lock();
+
+    if (tileCache.hasTile(ri))
     {
-      m_renderQueue.TileCache().touchTile(ri);
-      Tile tile = m_renderQueue.TileCache().getTile(ri);
-      m_renderQueue.TileCache().unlock();
+      tileCache.touchTile(ri);
+      Tile tile = tileCache.getTile(ri);
+      tileCache.unlock();
 
       size_t tileWidth = tile.m_renderTarget->width();
       size_t tileHeight = tile.m_renderTarget->height();
@@ -106,11 +108,11 @@ void TilingRenderPolicyMT::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBas
     }
     else
     {
-      m_renderQueue.TileCache().unlock();
-      m_renderQueue.AddCommand(renderFn(), ri, m_tiler.seqNum(), bind(&WindowHandle::invalidate, windowHandle()));
+      tileCache.unlock();
+      m_renderQueue.AddCommand(renderFn(), ri, m_tiler.sequenceID(), bind(&WindowHandle::invalidate, windowHandle()));
     }
   }
 
-  m_infoLayer.draw(pDrawer->screen().get(),
-                   math::Identity<double, 3>());*/
+//  m_infoLayer.draw(pDrawer->screen().get(),
+//                   math::Identity<double, 3>());
 }

map/tiling_render_policy_mt.hpp

@@ -23,11 +23,11 @@ class TilingRenderPolicyMT : public RenderPolicy
 private:
 
   RenderQueue m_renderQueue;
-  CoverageGenerator m_coverageGenerator;
+//  CoverageGenerator m_coverageGenerator;
 
   yg::InfoLayer m_infoLayer;
 
-//  yg::Tiler m_tiler;
+  Tiler m_tiler;
 
 public: