mnalis/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

added Tile, Tiler and TileCache classes. implemented tile priority sorting predicate to determine the order in which tiles are rendered.

Browse source
This commit is contained in:
rachytski 2011-06-26 16:11:39 +03:00 • committed by Alex Zolotarev
parent 7e3ae74fc1
commit 6717f0bbcf
11 changed files with 310 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
base/cache.hpp
View file

@ -56,6 +56,12 @@ namespace my
return data.m_Value;
}
bool HasKey(KeyT const & key)
{
Data & data = m_Cache[Hash(key) & m_HashMask];
return data.m_Key == key;
}
template <typename F>
void ForEachValue(F f)
{

36
map/framework.cpp
View file

@ -352,7 +352,8 @@ void FrameWork<TModel>::AddRedrawCommandSure()
m_metresMinWidth(20),
m_minRulerWidth(97),
m_centeringMode(EDoNothing),
m_maxDuration(0)
m_maxDuration(0),
m_tileSize(512)
{
m_startTime = my::FormatCurrentTime();
@ -893,6 +894,35 @@ void FrameWork<TModel>::AddRedrawCommandSure()
m_renderQueue.renderState().m_actualScreen,
currentScreen);
/* m_tiler.seed(currentScreen, m_tileSize);
while (m_tiler.hasTile())
{
yg::Tiler::RectInfo ri = m_tiler.nextTile();
m_renderQueue.tileCache().lock();
if (m_renderQueue.tileCache().hasTile(ri))
{
yg::Tile tile = m_renderQueue.tileCache().getTile(ri);
m2::RectD pxRect;
currentScreen.GtoP(ri.m_rect, pxRect);
pDrawer->screen()->drawRectangle(pxRect, yg::Color(255, 0, 0, 64), yg::maxDepth - 1);
m_renderQueue.tileCache().unlock();
// pDrawer->screen()->blit(tile.m_renderTarget, tile.m_tileScreen, currentScreen);
}
else
{
m_renderQueue.tileCache().unlock();
// m_renderQueue.addTileRenderCmd();
m2::RectD pxRect;
currentScreen.GtoP(ri.m_rect, pxRect);
pDrawer->screen()->drawRectangle(pxRect, yg::Color(0, 0, 255, 192 - (ri.m_distance * 3 > 255 ? 255 : ri.m_distance * 3) / (255.0 / 192)), yg::maxDepth - 2);
}
}
*/
m_informationDisplay.doDraw(pDrawer);
/* m_renderQueue.renderState().m_actualInfoLayer->draw(
@ -1042,7 +1072,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
m2::PointD ptShift = m_renderQueue.renderState().coordSystemShift(true);
m2::PointD pos = m_navigator.OrientPoint(e.Pos()) + ptShift;
m_navigator.DoDrag(pos, m_timer.ElapsedSeconds());
m_navigator.DoDrag(pos, GetPlatform().TimeInSec());
#ifdef DRAW_TOUCH_POINTS
m_informationDisplay.setDebugPoint(0, pos);
@ -1071,6 +1101,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
void FrameWork<TModel>::Move(double azDir, double factor)
{
m_navigator.Move(azDir, factor);
// m_tiler.seed(m_navigator.Screen(), m_tileSize);
UpdateNow();
}
//@}
@ -1099,6 +1130,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
void FrameWork<TModel>::Scale(double scale)
{
m_navigator.Scale(scale);
// m_tiler.seed(m_navigator.Screen(), m_tileSize);
UpdateNow();
}

6
map/framework.hpp
View file

@ -25,6 +25,7 @@
#include "../yg/render_state.hpp"
#include "../yg/skin.hpp"
#include "../yg/resource_manager.hpp"
#include "../yg/tiler.hpp"
#include "../coding/file_reader.hpp"
#include "../coding/file_writer.hpp"
@ -127,7 +128,6 @@ class FrameWork
double const m_metresMinWidth;
int const m_minRulerWidth;
enum TGpsCenteringMode
{
EDoNothing,
@ -148,6 +148,8 @@ class FrameWork
m2::RectD m_maxDurationRect;
m2::RectD m_curBenchmarkRect;
int m_tileSize;
struct BenchmarkResult
{
string m_name;
@ -169,6 +171,8 @@ class FrameWork
vector<Benchmark> m_benchmarks;
size_t m_curBenchmark;
yg::Tiler m_tiler;
void BenchmarkCommandFinished();
void NextBenchmarkCommand();
void SaveBenchmarkResults();

8
map/render_queue.cpp
View file

@ -14,7 +14,8 @@ RenderQueue::RenderQueue(
unsigned scaleEtalonSize,
yg::Color const & bgColor
)
: m_renderState(new yg::gl::RenderState())
: m_renderState(new yg::gl::RenderState()),
m_tileCache(256 * 256 * 2, 10 * 1024 * 1024)
{
m_renderState->m_surfaceWidth = 100;
m_renderState->m_surfaceHeight = 100;
@ -111,4 +112,9 @@ void RenderQueue::enterForeground()
m_routine->enterForeground();
}
yg::TileCache & RenderQueue::tileCache()
{
return m_tileCache;
}

11
map/render_queue.hpp
View file

@ -4,6 +4,8 @@
#include "../geometry/screenbase.hpp"
#include "../std/shared_ptr.hpp"
#include "render_queue_routine.hpp"
#include "../yg/tile_cache.hpp"
#include "../yg/tiler.hpp"
namespace yg
{
@ -29,6 +31,8 @@ private:
shared_ptr<yg::ResourceManager> m_resourceManager;
RenderQueueRoutine * m_routine;
yg::TileCache m_tileCache;
public:
typedef RenderQueueRoutine::renderCommandFinishedFn renderCommandFinishedFn;
@ -69,11 +73,16 @@ public:
yg::gl::RenderState const & renderState() const;
/// free all possible memory caches
/// free all possible memory caches.
void memoryWarning();
/// free all possible memory caches, opengl resources,
/// and make sure no opengl call will be made in background
void enterBackground();
/// load all necessary memory caches and opengl resources.
void enterForeground();
/// get tile cache.
yg::TileCache & tileCache();
/// add tiler rendering command.
void addTileRenderCmd(yg::Tiler::RectInfo const & ri);
};

18
yg/tile.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "../geometry/screenbase.hpp"
#include "../std/shared_ptr.hpp"
#include "base_texture.hpp"
#include "renderbuffer.hpp"
#include "tiler.hpp"
namespace yg
{
struct Tile
{
shared_ptr<gl::RenderBuffer> m_depthBuffer; //< taken from resource manager
shared_ptr<gl::BaseTexture> m_renderTarget; //< taken from resource manager
ScreenBase m_tileScreen;
Tiler::RectInfo m_rectInfo; //< taken from tiler
};
}

37
yg/tile_cache.cpp Normal file
View file

@ -0,0 +1,37 @@
#include "tile_cache.hpp"
namespace yg
{
TileCache::TileCache(size_t tileMemSize, size_t memSize)
: m_cache(log(memSize / tileMemSize) / log(2))
{
}
void TileCache::addTile(Tiler::RectInfo const & key, Tile const & value)
{
bool found;
Tile & cachedVal = m_cache.Find(key.toUInt64Cell(), found);
cachedVal = value;
}
void TileCache::lock()
{
m_mutex.Lock();
}
void TileCache::unlock()
{
m_mutex.Unlock();
}
bool TileCache::hasTile(Tiler::RectInfo const & key)
{
return m_cache.HasKey(key.toUInt64Cell());
}
Tile const & TileCache::getTile(Tiler::RectInfo const & key)
{
bool found;
return m_cache.Find(key.toUInt64Cell(), found);
}
}

31
yg/tile_cache.hpp Normal file
View file

@ -0,0 +1,31 @@
#pragma once
#include "tile.hpp"
#include "tiler.hpp"
#include "../base/cache.hpp"
#include "../base/mutex.hpp"
namespace yg
{
class TileCache
{
private:
my::Cache<uint64_t, Tile> m_cache;
threads::Mutex m_mutex;
public:
TileCache(size_t tileMemSize, size_t memSize);
/// lock for multithreaded access
void lock();
/// unlock for multithreaded access
void unlock();
/// add tile to cache
void addTile(Tiler::RectInfo const & key, Tile const & value);
/// check, whether we have some tile in the cache
bool hasTile(Tiler::RectInfo const & key);
/// get tile from the cache
Tile const & getTile(Tiler::RectInfo const & key);
};
}

99
yg/tiler.cpp Normal file
View file

@ -0,0 +1,99 @@
#include "../base/SRC_FIRST.hpp"
#include "tiler.hpp"
#include "../indexer/mercator.hpp"
#include "../indexer/scales.hpp"
namespace yg
{
uint64_t Tiler::RectInfo::toUInt64Cell() const
{
/// pack y in 0-16 bits
/// pack x in 17-33 bits
/// pack scale in 34-40 bits
return ((m_y & 0x1FF) | ((m_x & 0x1FF) << 17) | ((uint64_t)m_scale & 0x1F) << 34);
}
void Tiler::RectInfo::fromUInt64Cell(uint64_t v, m2::RectD const & globRect)
{
m_y = v & 0x1FF;
m_x = (v >> 17) & 0x1FF;
m_scale = (v >> 34) & 0x1F;
init(globRect);
}
Tiler::RectInfo::RectInfo()
: m_scale(0), m_x(0), m_y(0), m_coverage(0), m_distance(0)
{}
Tiler::RectInfo::RectInfo(int scale, int x, int y, m2::RectD const & globRect)
: m_scale(scale), m_x(x), m_y(y)
{
init(globRect);
}
void Tiler::RectInfo::init(m2::RectD const & globRect)
{
int k = 1 << m_scale;
double rectSizeX = (MercatorBounds::maxX - MercatorBounds::minX) / k;
double rectSizeY = (MercatorBounds::maxY - MercatorBounds::minY) / k;
m_rect.setMinX(m_x * rectSizeX);
m_rect.setMaxX((m_x + 1) * rectSizeX);
m_rect.setMinY(m_y * rectSizeY);
m_rect.setMaxY((m_y + 1) * rectSizeY);
m_distance = m_rect.Center().Length(globRect.Center());
m2::RectD r = globRect;
if (r.Intersect(m_rect))
m_coverage = r.SizeX() * r.SizeY() / (m_rect.SizeX() * m_rect.SizeY());
else
m_coverage = 0;
}
bool operator<(Tiler::RectInfo const & l, Tiler::RectInfo const & r)
{
if (l.m_coverage != r.m_coverage)
return l.m_coverage < r.m_coverage;
return l.m_distance < r.m_distance;
}
void Tiler::seed(ScreenBase const & screen, int scaleEtalonSize)
{
m2::RectD glbRect;
m2::PointD pxCenter = screen.PixelRect().Center();
screen.PtoG(m2::RectD(pxCenter - m2::PointD(scaleEtalonSize / 2, scaleEtalonSize / 2),
pxCenter + m2::PointD(scaleEtalonSize / 2, scaleEtalonSize / 2)),
glbRect);
m_scale = scales::GetScaleLevel(glbRect);
m_screen = screen;
m2::RectD const screenRect = m_screen.GlobalRect();
double rectSizeX = (MercatorBounds::maxX - MercatorBounds::minX) / (1 << m_scale);
double rectSizeY = (MercatorBounds::maxY - MercatorBounds::minY) / (1 << m_scale);
int minTileX = floor(screenRect.minX() / rectSizeX);
int maxTileX = ceil(screenRect.maxX() / rectSizeX);
int minTileY = floor(screenRect.minY() / rectSizeY);
int maxTileY = ceil(screenRect.maxY() / rectSizeY);
for (int tileY = minTileY; tileY < maxTileY; ++tileY)
for (int tileX = minTileX; tileX < maxTileX; ++tileX)
m_coverage.push(RectInfo(m_scale, tileX, tileY, screenRect));
}
bool Tiler::hasTile()
{
return !m_coverage.empty();
}
Tiler::RectInfo const Tiler::nextTile()
{
RectInfo r = m_coverage.top();
m_coverage.pop();
return r;
}
}

55
yg/tiler.hpp Normal file
View file

@ -0,0 +1,55 @@
#pragma once
#include "../geometry/screenbase.hpp"
#include "../geometry/rect2d.hpp"
#include "../std/queue.hpp"
namespace yg
{
class Tiler
{
public:
struct RectInfo
{
int m_scale;
int m_x;
int m_y;
m2::RectD m_rect;
double m_distance;
double m_coverage;
RectInfo();
RectInfo(int scale, int x, int y, m2::RectD const & globRect);
void init(m2::RectD const & globRect);
/// pack scale, x, y into 64 bit word to use it as a hash-map key
uint64_t toUInt64Cell() const;
/// unpack 64bit integer and compute other parameters
void fromUInt64Cell(uint64_t v, m2::RectD const & globRect);
};
private:
ScreenBase m_screen;
int m_scale;
priority_queue<RectInfo> m_coverage;
public:
/// seed tiler with new screenBase.
/// if there are an existing tile sequence it is
/// reorganized to reflect screen changes.
void seed(ScreenBase const & screenBase, int scaleEtalonSize);
/// check whether the sequence has next tile
bool hasTile();
/// pop tile from the sequence and return it
RectInfo const nextTile();
};
bool operator <(Tiler::RectInfo const & l, Tiler::RectInfo const & r);
}

11
yg/yg.pro
View file

@ -6,7 +6,7 @@ CONFIG += staticlib
DEFINES += YG_LIBRARY
ROOT_DIR = ..
DEPENDENCIES = geometry coding base freetype fribidi expat
DEPENDENCIES = indexer geometry coding base freetype fribidi expat
INCLUDEPATH += $$ROOT_DIR/3party/freetype/include $$ROOT_DIR/3party/agg
@ -61,7 +61,9 @@ SOURCES += \
info_layer.cpp \
overlay_element.cpp \
symbol_element.cpp \
overlay_renderer.cpp
overlay_renderer.cpp \
tiler.cpp \
tile_cache.cpp
HEADERS += \
internal/opengl.hpp \
@ -115,7 +117,10 @@ HEADERS += \
info_layer.hpp \
overlay_element.hpp \
symbol_element.hpp \
overlay_renderer.hpp
overlay_renderer.hpp \
tile.hpp \
tile_cache.hpp \
tiler.hpp
win32 {
HEADERS += internal/opengl_win32.hpp