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

added merging of separate tile-level infolayers into big one. introduced IsMultiThreadedRendering setting into Platform interface.

Browse source
This commit is contained in:
rachytski 2011-07-13 22:26:04 +03:00 • committed by Alex Zolotarev
parent db71528914
commit bc1f646c75
23 changed files with 653 additions and 409 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -88,6 +88,8 @@ android/.classpath
android/.cproject
android/.project
android/assets
# local android scripts, such as debugger helper scrips
android/local
qtc_packaging

243
map/draw_processor.cpp
View file

@ -1,8 +1,15 @@
#include "draw_processor.hpp"
#include "drawer_yg.hpp"
#include "languages.hpp"
#include "../geometry/screenbase.hpp"
#include "../geometry/rect_intersect.hpp"
#include "../indexer/feature_visibility.hpp"
#include "../indexer/drawing_rules.hpp"
#include "../indexer/feature_data.hpp"
#include "../std/bind.hpp"
#include "../base/start_mem_debug.hpp"
@ -177,3 +184,239 @@ bool area_tess_points::IsExist() const
}
}
namespace fwork
{
namespace
{
template <class TSrc> void assign_point(di::DrawInfo * p, TSrc & src)
{
p->m_point = src.m_point;
}
template <class TSrc> void assign_path(di::DrawInfo * p, TSrc & src)
{
p->m_pathes.swap(src.m_points);
}
template <class TSrc> void assign_area(di::DrawInfo * p, TSrc & src)
{
p->m_areas.swap(src.m_points);
ASSERT ( !p->m_areas.empty(), () );
p->m_areas.back().SetCenter(src.GetCenter());
}
}
DrawProcessor::DrawProcessor( m2::RectD const & r,
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
yg::GlyphCache * glyphCache)
: m_rect(r),
m_convertor(convertor),
m_paintEvent(paintEvent),
m_zoom(scaleLevel),
m_glyphCache(glyphCache)
#ifdef PROFILER_DRAWING
, m_drawCount(0)
#endif
{
m_keys.reserve(reserve_rules_count);
GetDrawer()->SetScale(m_zoom);
}
namespace
{
struct less_depth
{
bool operator() (di::DrawRule const & r1, di::DrawRule const & r2) const
{
return (r1.m_depth < r2.m_depth);
}
};
struct less_key
{
bool operator() (drule::Key const & r1, drule::Key const & r2) const
{
if (r1.m_type == r2.m_type)
{
// assume that unique algo leaves the first element (with max priority), others - go away
return (r1.m_priority > r2.m_priority);
}
else
return (r1.m_type < r2.m_type);
}
};
struct equal_key
{
bool operator() (drule::Key const & r1, drule::Key const & r2) const
{
// many line and area rules - is ok, other rules - one is enough
if (r1.m_type == drule::line || r1.m_type == drule::area)
return (r1 == r2);
else
return (r1.m_type == r2.m_type);
}
};
}
void DrawProcessor::PreProcessKeys()
{
sort(m_keys.begin(), m_keys.end(), less_key());
m_keys.erase(unique(m_keys.begin(), m_keys.end(), equal_key()), m_keys.end());
}
#define GET_POINTS(f, for_each_fun, fun, assign_fun) \
{ \
f.for_each_fun(fun, m_zoom); \
if (fun.IsExist()) \
{ \
isExist = true; \
assign_fun(ptr.get(), fun); \
} \
}
bool DrawProcessor::operator()(FeatureType const & f)
{
if (m_paintEvent->isCancelled())
throw redraw_operation_cancelled();
// get drawing rules
m_keys.clear();
string names; // for debug use only, in release it's empty
int type = feature::GetDrawRule(f, m_zoom, m_keys, names);
if (m_keys.empty())
{
// Index can pass here invisible features.
// During indexing, features are placed at first visible scale bucket.
// At higher scales it can become invisible - it depends on classificator.
return true;
}
// remove duplicating identical drawing keys
PreProcessKeys();
// get drawing rules for the m_keys array
size_t const count = m_keys.size();
#ifdef PROFILER_DRAWING
m_drawCount += count;
#endif
buffer_vector<di::DrawRule, reserve_rules_count> rules;
rules.resize(count);
int layer = f.GetLayer();
bool isTransparent = false;
if (layer == feature::LAYER_TRANSPARENT_TUNNEL)
{
layer = 0;
isTransparent = true;
}
for (size_t i = 0; i < count; ++i)
{
int depth = m_keys[i].m_priority;
if (layer != 0)
depth = (layer * drule::layer_base_priority) + (depth % drule::layer_base_priority);
rules[i] = di::DrawRule(drule::rules().Find(m_keys[i]), depth, isTransparent);
}
sort(rules.begin(), rules.end(), less_depth());
shared_ptr<di::DrawInfo> ptr(new di::DrawInfo(
f.GetPreferredDrawableName(languages::GetCurrentPriorities()),
f.GetRoadNumber(),
(m_zoom > 5) ? f.GetPopulationDrawRank() : 0.0));
DrawerYG * pDrawer = GetDrawer();
using namespace get_pts;
bool isExist = false;
switch (type)
{
case feature::GEOM_POINT:
{
typedef get_pts::one_point functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_point)
break;
}
case feature::GEOM_AREA:
{
typedef filter_screenpts_adapter<area_tess_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachTriangleExRef, fun, assign_area)
{
// if area feature has any line-drawing-rules, than draw it like line
for (size_t i = 0; i < m_keys.size(); ++i)
if (m_keys[i].m_type == drule::line)
goto draw_line;
break;
}
}
draw_line:
case feature::GEOM_LINE:
{
typedef filter_screenpts_adapter<path_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
if (!ptr->m_name.empty())
{
double fontSize = 0;
for (size_t i = 0; i < count; ++i)
{
if (pDrawer->filter_text_size(rules[i].m_rule))
fontSize = max((uint8_t)fontSize, pDrawer->get_pathtext_font_size(rules[i].m_rule));
}
if (fontSize != 0)
{
double textLength = m_glyphCache->getTextLength(fontSize, ptr->m_name);
typedef calc_length<base_global> functor_t;
functor_t::params p1;
p1.m_convertor = &m_convertor;
p1.m_rect = &m_rect;
functor_t fun(p1);
f.ForEachPointRef(fun, m_zoom);
if ((fun.IsExist()) && (fun.m_length > textLength))
{
textLength += 50;
p.m_startLength = (fun.m_length - textLength) / 2;
p.m_endLength = p.m_startLength + textLength;
}
}
}
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_path)
break;
}
}
if (isExist)
pDrawer->Draw(ptr.get(), rules.data(), count);
return true;
}
}

50
map/draw_processor.hpp
View file

@ -1,7 +1,13 @@
#pragma once
#include "draw_info.hpp"
#include "draw_info.hpp"
#include "events.hpp"
#include "../indexer/drawing_rule_def.hpp"
#include "../indexer/feature.hpp"
#include "../indexer/cell_id.hpp" // CoordPointT
#include "../indexer/data_header.hpp"
#include "../indexer/feature_data.hpp"
#include "../geometry/point2d.hpp"
#include "../geometry/rect2d.hpp"
@ -300,3 +306,45 @@ namespace get_pts
m2::PointD GetCenter() const { return m_center / (3*m_count); }
};
}
namespace drule { class BaseRule; }
namespace di { class DrawInfo; }
class redraw_operation_cancelled {};
namespace fwork
{
class DrawProcessor
{
m2::RectD m_rect;
ScreenBase const & m_convertor;
shared_ptr<PaintEvent> m_paintEvent;
vector<drule::Key> m_keys;
int m_zoom;
yg::GlyphCache * m_glyphCache;
#ifdef PROFILER_DRAWING
size_t m_drawCount;
#endif
inline DrawerYG * GetDrawer() const { return m_paintEvent->drawer().get(); }
void PreProcessKeys();
static const int reserve_rules_count = 16;
public:
DrawProcessor(m2::RectD const & r,
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
yg::GlyphCache * glyphCache);
bool operator() (FeatureType const & f);
};
}

14
map/drawer_yg.cpp
View file

@ -97,7 +97,7 @@ void DrawerYG::onSize(int w, int h)
void DrawerYG::drawSymbol(m2::PointD const & pt, string const & symbolName, yg::EPosition pos, int depth)
{
m_pScreen->drawSymbol(pt, m_pSkin->mapSymbol(symbolName.c_str()), pos, depth);
m_pScreen->drawSymbol(pt, symbolName.c_str(), pos, depth);
}
void DrawerYG::drawCircle(m2::PointD const & pt, rule_ptr_t pRule, yg::EPosition pos, int depth)
@ -134,10 +134,12 @@ void DrawerYG::drawSymbol(m2::PointD const & pt, rule_ptr_t pRule, yg::EPosition
// This rules doesn't mix with other rule-types.
uint32_t id = pRule->GetID(m_threadID);
if (id == drule::BaseRule::empty_id)
string name;
pRule->GetSymbol(name);
/* if (id == drule::BaseRule::empty_id)
{
string name;
pRule->GetSymbol(name);
id = m_pSkin->mapSymbol(name.c_str());
if (id != drule::BaseRule::empty_id)
@ -147,9 +149,9 @@ void DrawerYG::drawSymbol(m2::PointD const & pt, rule_ptr_t pRule, yg::EPosition
//ASSERT ( false, ("Can't find symbol by id = ", (name)) );
return;
}
}
}*/
m_pScreen->drawSymbol(pt, id, pos, depth);
m_pScreen->drawSymbol(pt, name, pos, depth);
}
void DrawerYG::drawPath(di::PathInfo const & info, di::DrawRule const * rules, size_t count)

370
map/framework.cpp
View file

@ -31,255 +31,6 @@
using namespace feature;
namespace fwork
{
namespace
{
template <class TSrc> void assign_point(di::DrawInfo * p, TSrc & src)
{
p->m_point = src.m_point;
}
template <class TSrc> void assign_path(di::DrawInfo * p, TSrc & src)
{
p->m_pathes.swap(src.m_points);
}
template <class TSrc> void assign_area(di::DrawInfo * p, TSrc & src)
{
p->m_areas.swap(src.m_points);
ASSERT ( !p->m_areas.empty(), () );
p->m_areas.back().SetCenter(src.GetCenter());
}
}
DrawProcessor::DrawProcessor( m2::RectD const & r,
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
yg::GlyphCache * glyphCache)
: m_rect(r),
m_convertor(convertor),
m_paintEvent(paintEvent),
m_zoom(scaleLevel),
m_glyphCache(glyphCache)
#ifdef PROFILER_DRAWING
, m_drawCount(0)
#endif
{
m_keys.reserve(reserve_rules_count);
GetDrawer()->SetScale(m_zoom);
}
namespace
{
struct less_depth
{
bool operator() (di::DrawRule const & r1, di::DrawRule const & r2) const
{
return (r1.m_depth < r2.m_depth);
}
};
struct less_key
{
bool operator() (drule::Key const & r1, drule::Key const & r2) const
{
if (r1.m_type == r2.m_type)
{
// assume that unique algo leaves the first element (with max priority), others - go away
return (r1.m_priority > r2.m_priority);
}
else
return (r1.m_type < r2.m_type);
}
};
struct equal_key
{
bool operator() (drule::Key const & r1, drule::Key const & r2) const
{
// many line and area rules - is ok, other rules - one is enough
if (r1.m_type == drule::line || r1.m_type == drule::area)
return (r1 == r2);
else
return (r1.m_type == r2.m_type);
}
};
}
void DrawProcessor::PreProcessKeys()
{
sort(m_keys.begin(), m_keys.end(), less_key());
m_keys.erase(unique(m_keys.begin(), m_keys.end(), equal_key()), m_keys.end());
}
#define GET_POINTS(f, for_each_fun, fun, assign_fun) \
{ \
f.for_each_fun(fun, m_zoom); \
if (fun.IsExist()) \
{ \
isExist = true; \
assign_fun(ptr.get(), fun); \
} \
}
bool DrawProcessor::operator()(FeatureType const & f)
{
if (m_paintEvent->isCancelled())
throw redraw_operation_cancelled();
// get drawing rules
m_keys.clear();
string names; // for debug use only, in release it's empty
int type = feature::GetDrawRule(f, m_zoom, m_keys, names);
if (m_keys.empty())
{
// Index can pass here invisible features.
// During indexing, features are placed at first visible scale bucket.
// At higher scales it can become invisible - it depends on classificator.
return true;
}
// remove duplicating identical drawing keys
PreProcessKeys();
// get drawing rules for the m_keys array
size_t const count = m_keys.size();
#ifdef PROFILER_DRAWING
m_drawCount += count;
#endif
buffer_vector<di::DrawRule, reserve_rules_count> rules;
rules.resize(count);
int layer = f.GetLayer();
bool isTransparent = false;
if (layer == feature::LAYER_TRANSPARENT_TUNNEL)
{
layer = 0;
isTransparent = true;
}
for (size_t i = 0; i < count; ++i)
{
int depth = m_keys[i].m_priority;
if (layer != 0)
depth = (layer * drule::layer_base_priority) + (depth % drule::layer_base_priority);
rules[i] = di::DrawRule(drule::rules().Find(m_keys[i]), depth, isTransparent);
}
sort(rules.begin(), rules.end(), less_depth());
shared_ptr<di::DrawInfo> ptr(new di::DrawInfo(
f.GetPreferredDrawableName(languages::GetCurrentPriorities()),
f.GetRoadNumber(),
(m_zoom > 5) ? f.GetPopulationDrawRank() : 0.0));
DrawerYG * pDrawer = GetDrawer();
using namespace get_pts;
bool isExist = false;
switch (type)
{
case GEOM_POINT:
{
typedef get_pts::one_point functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_point)
break;
}
case GEOM_AREA:
{
typedef filter_screenpts_adapter<area_tess_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
functor_t fun(p);
GET_POINTS(f, ForEachTriangleExRef, fun, assign_area)
{
// if area feature has any line-drawing-rules, than draw it like line
for (size_t i = 0; i < m_keys.size(); ++i)
if (m_keys[i].m_type == drule::line)
goto draw_line;
break;
}
}
draw_line:
case GEOM_LINE:
{
typedef filter_screenpts_adapter<path_points> functor_t;
functor_t::params p;
p.m_convertor = &m_convertor;
p.m_rect = &m_rect;
if (!ptr->m_name.empty())
{
double fontSize = 0;
for (size_t i = 0; i < count; ++i)
{
if (pDrawer->filter_text_size(rules[i].m_rule))
fontSize = max((uint8_t)fontSize, pDrawer->get_pathtext_font_size(rules[i].m_rule));
}
if (fontSize != 0)
{
double textLength = m_glyphCache->getTextLength(fontSize, ptr->m_name);
typedef calc_length<base_global> functor_t;
functor_t::params p1;
p1.m_convertor = &m_convertor;
p1.m_rect = &m_rect;
functor_t fun(p1);
f.ForEachPointRef(fun, m_zoom);
if ((fun.IsExist()) && (fun.m_length > textLength))
{
textLength += 50;
p.m_startLength = (fun.m_length - textLength) / 2;
p.m_endLength = p.m_startLength + textLength;
}
}
}
functor_t fun(p);
GET_POINTS(f, ForEachPointRef, fun, assign_path)
break;
}
}
if (isExist)
pDrawer->Draw(ptr.get(), rules.data(), count);
return true;
}
}
/*template <typename TModel>
void FrameWork<TModel>::AddRedrawCommandSure()
{
}*/
/* template <typename TModel>
void FrameWork<TModel>::AddRedrawCommand()
{
yg::gl::RenderState const state = m_renderQueue.CopyState();
if ((state.m_currentScreen != m_navigator.Screen()) && (m_isRedrawEnabled))
AddRedrawCommandSure();
}*/
template <typename TModel>
void FrameWork<TModel>::AddMap(string const & file)
@ -687,7 +438,39 @@ void FrameWork<TModel>::AddRedrawCommandSure()
shared_ptr<yg::ResourceManager> const & resourceManager)
{
m_resourceManager = resourceManager;
m_renderQueue.InitializeGL(primaryContext, m_resourceManager, GetPlatform().VisualScale());
if (GetPlatform().IsMultiThreadedRendering())
m_renderQueue.InitializeGL(primaryContext, m_resourceManager, GetPlatform().VisualScale());
else
{
/// render single tile on the same thread
shared_ptr<yg::gl::FrameBuffer> frameBuffer(new yg::gl::FrameBuffer());
unsigned tileWidth = m_resourceManager->tileTextureWidth();
unsigned tileHeight = m_resourceManager->tileTextureHeight();
shared_ptr<yg::gl::RenderBuffer> depthBuffer(new yg::gl::RenderBuffer(tileWidth, tileHeight, true));
frameBuffer->setDepthBuffer(depthBuffer);
DrawerYG::params_t params;
shared_ptr<yg::InfoLayer> infoLayer(new yg::InfoLayer());
params.m_resourceManager = m_resourceManager;
params.m_frameBuffer = frameBuffer;
params.m_infoLayer = infoLayer;
params.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID();
params.m_useOverlay = true;
params.m_threadID = 0;
m_tileDrawer = make_shared_ptr(new DrawerYG(GetPlatform().SkinName(), params));
m_tileDrawer->onSize(tileWidth, tileHeight);
m_tileDrawer->SetVisualScale(GetPlatform().VisualScale());
m2::RectI renderRect(1, 1, tileWidth - 1, tileWidth - 1);
m_tileScreen.OnSize(renderRect);
}
}
template <typename TModel>
@ -840,22 +623,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
try
{
threads::MutexGuard lock(m_modelSyn);
#ifdef PROFILER_DRAWING
using namespace prof;
start<for_each_feature>();
reset<feature_count>();
#endif
m_model.ForEachFeatureWithScale(selectRect, bind<bool>(ref(doDraw), _1), scaleLevel);
#ifdef PROFILER_DRAWING
end<for_each_feature>();
LOG(LPROF, ("ForEachFeature=", metric<for_each_feature>(),
"FeatureCount=", metric<feature_count>(),
"TextureUpload= ", metric<yg_upload_data>()));
#endif
}
catch (redraw_operation_cancelled const &)
{
@ -871,9 +639,6 @@ void FrameWork<TModel>::AddRedrawCommandSure()
template <typename TModel>
void FrameWork<TModel>::Paint(shared_ptr<PaintEvent> e)
{
// Making a copy of actualFrameInfo to compare without synchronizing.
//typename yg::gl::RenderState state = m_renderQueue.CopyState();
DrawerYG * pDrawer = e->drawer().get();
m_informationDisplay.setScreen(m_navigator.Screen());
@ -918,6 +683,8 @@ void FrameWork<TModel>::AddRedrawCommandSure()
m_renderQueue.renderState().m_actualScreen,
currentScreen);*/
m_infoLayer.clear();
m_tiler.seed(currentScreen,
currentScreen.GlobalRect().Center(),
m_tileSize,
@ -942,19 +709,74 @@ void FrameWork<TModel>::AddRedrawCommandSure()
yg::Color(),
m2::RectI(0, 0, tileWidth - 2, tileHeight - 2),
m2::RectU(1, 1, tileWidth - 1, tileHeight - 1));
m_infoLayer.merge(*tile.m_infoLayer.get(), tile.m_tileScreen.PtoGMatrix() * currentScreen.GtoPMatrix());
}
else
{
m_renderQueue.TileCache().unlock();
m_renderQueue.AddCommand(bind(&this_type::PaintImpl, this, _1, _2, _3, _4), ri, m_tiler.seqNum());
if (GetPlatform().IsMultiThreadedRendering())
{
m_renderQueue.TileCache().unlock();
m_renderQueue.AddCommand(bind(&this_type::PaintImpl, this, _1, _2, _3, _4), ri, m_tiler.seqNum());
}
else
{
m_renderQueue.TileCache().unlock();
shared_ptr<PaintEvent> paintEvent(new PaintEvent(m_tileDrawer));
shared_ptr<yg::gl::BaseTexture> tileTarget = m_resourceManager->renderTargets().Front(true);
shared_ptr<yg::InfoLayer> tileInfoLayer(new yg::InfoLayer());
m_tileDrawer->screen()->setRenderTarget(tileTarget);
m_tileDrawer->screen()->setInfoLayer(tileInfoLayer);
m_tileDrawer->beginFrame();
m_tileDrawer->clear(yg::Color(m_bgColor.r, m_bgColor.g, m_bgColor.b, 0));
m2::RectI renderRect(1, 1, m_resourceManager->tileTextureWidth() - 1, m_resourceManager->tileTextureHeight() - 1);
m_tileDrawer->screen()->setClipRect(renderRect);
m_tileDrawer->clear(m_bgColor);
m_tileScreen.SetFromRect(ri.m_rect);
m2::RectD selectionRect;
double inflationSize = 24 * GetPlatform().VisualScale();
m_tileScreen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), selectionRect);
PaintImpl(paintEvent,
m_tileScreen,
selectionRect,
ri.m_drawScale);
m_tileDrawer->endFrame();
m_tileDrawer->screen()->resetInfoLayer();
yg::Tile tile(tileTarget, tileInfoLayer, m_tileScreen, ri, 0);
m_renderQueue.TileCache().lock();
m_renderQueue.TileCache().addTile(ri, yg::TileCache::Entry(tile, m_resourceManager));
m_renderQueue.TileCache().unlock();
m_renderQueue.TileCache().touchTile(ri);
tile = m_renderQueue.TileCache().getTile(ri);
m_renderQueue.TileCache().unlock();
size_t tileWidth = tile.m_renderTarget->width();
size_t tileHeight = tile.m_renderTarget->height();
pDrawer->screen()->blit(tile.m_renderTarget, tile.m_tileScreen, currentScreen, true,
yg::Color(),
m2::RectI(0, 0, tileWidth - 2, tileHeight - 2),
m2::RectU(1, 1, tileWidth - 1, tileHeight - 1));
}
}
}
m_informationDisplay.doDraw(pDrawer);
m_infoLayer.draw(pDrawer->screen().get(),
math::Identity<double, 3>());
/* m_renderQueue.renderState().m_actualInfoLayer->draw(
pDrawer->screen().get(),
m_renderQueue.renderState().m_actualScreen.PtoGMatrix() * currentScreen.GtoPMatrix());*/
m_informationDisplay.doDraw(pDrawer);
m_locationState.DrawMyPosition(*pDrawer, m_navigator.Screen());

51
map/framework.hpp
View file

@ -10,11 +10,9 @@
#include "../defines.hpp"
#include "../indexer/drawing_rule_def.hpp"
#include "../indexer/mercator.hpp"
#include "../indexer/data_header.hpp"
#include "../indexer/scales.hpp"
#include "../indexer/feature.hpp"
#include "../platform/platform.hpp"
#include "../platform/location.hpp"
@ -26,6 +24,7 @@
#include "../yg/skin.hpp"
#include "../yg/resource_manager.hpp"
#include "../yg/tiler.hpp"
#include "../yg/info_layer.hpp"
#include "../coding/file_reader.hpp"
#include "../coding/file_writer.hpp"
@ -47,56 +46,17 @@
//#define DRAW_TOUCH_POINTS
namespace di { class DrawInfo; }
namespace drule { class BaseRule; }
namespace search { class Engine; }
class redraw_operation_cancelled {};
struct BenchmarkRectProvider;
namespace search { class Result; }
typedef function<void (search::Result const &)> SearchCallbackT;
namespace fwork
{
class DrawProcessor
{
m2::RectD m_rect;
ScreenBase const & m_convertor;
shared_ptr<PaintEvent> m_paintEvent;
vector<drule::Key> m_keys;
int m_zoom;
yg::GlyphCache * m_glyphCache;
#ifdef PROFILER_DRAWING
size_t m_drawCount;
#endif
inline DrawerYG * GetDrawer() const { return m_paintEvent->drawer().get(); }
void PreProcessKeys();
static const int reserve_rules_count = 16;
public:
DrawProcessor(m2::RectD const & r,
ScreenBase const & convertor,
shared_ptr<PaintEvent> const & paintEvent,
int scaleLevel,
yg::GlyphCache * glyphCache);
bool operator() (FeatureType const & f);
};
}
typedef function<void (void)> LocationRetrievedCallbackT;
class DrawerYG;
template
<
class TModel
@ -121,6 +81,11 @@ class FrameWork
shared_ptr<yg::ResourceManager> m_resourceManager;
InformationDisplay m_informationDisplay;
yg::InfoLayer m_infoLayer;
shared_ptr<DrawerYG> m_tileDrawer;
ScreenBase m_tileScreen;
/// is AddRedrawCommand enabled?
bool m_isRedrawEnabled;
double const m_metresMinWidth;

6
map/information_display.cpp
View file

@ -14,6 +14,8 @@
#include "../base/mutex.hpp"
#include "../base/macros.hpp"
#include "../geometry/transformations.hpp"
#include "../std/fstream.hpp"
#include "../std/iomanip.hpp"
@ -426,9 +428,9 @@ void InformationDisplay::drawEmptyModelMessage(DrawerYG * pDrawer)
params.m_logText = strings::MakeUniString(s0);
yg::StraightTextElement ste0(params);
ste0.offset(m2::PointD(0, -ste0.boundRect().GetGlobalRect().SizeY() - 5));
ste0.draw(pDrawer->screen().get(), math::Identity<double, 3>());
math::Matrix<double, 3, 3> m = math::Shift(math::Identity<double, 3>(), m2::PointD(0, -ste0.boundRect().GetGlobalRect().SizeY() - 5));
ste0.draw(pDrawer->screen().get(), m);
params.m_pivot = pt;
params.m_logText = strings::MakeUniString(s1);

10
map/map_tests/map_tests.pro
View file

@ -6,7 +6,7 @@ CONFIG -= app_bundle
TEMPLATE = app
ROOT_DIR = ../..
DEPENDENCIES = map indexer platform geometry coding base expat
DEPENDENCIES = map yg indexer platform geometry coding base expat freetype fribidi
include($$ROOT_DIR/common.pri)
@ -19,6 +19,14 @@ win32 {
}
}
!iphone*:!bada*:!android* {
QT += opengl
}
macx|iphone* {
LIBS += -framework Foundation
}
SOURCES += \
../../testing/testingmain.cpp \
navigator_test.cpp \

9
map/render_queue_routine.cpp
View file

@ -146,6 +146,10 @@ void RenderQueueRoutine::Do()
m_threadDrawer->screen()->setRenderTarget(tileTarget);
shared_ptr<yg::InfoLayer> tileInfoLayer(new yg::InfoLayer());
m_threadDrawer->screen()->setInfoLayer(tileInfoLayer);
m_threadDrawer->beginFrame();
m_threadDrawer->clear(yg::Color(m_bgColor.r, m_bgColor.g, m_bgColor.b, 0));
@ -154,7 +158,7 @@ void RenderQueueRoutine::Do()
frameScreen.SetFromRect(m_currentCommand->m_rectInfo.m_rect);
m2::RectD selectionRect; // = m_currentCommand->m_rectInfo.m_rect;
m2::RectD selectionRect;
double inflationSize = 24 * m_visualScale;
@ -170,6 +174,7 @@ void RenderQueueRoutine::Do()
// m_infoLayer->draw(m_threadDrawer->screen().get(), math::Identity<double, 3>());
m_threadDrawer->endFrame();
m_threadDrawer->screen()->resetInfoLayer();
double duration = timer.ElapsedSeconds();
@ -184,7 +189,7 @@ void RenderQueueRoutine::Do()
if (!m_currentCommand->m_paintEvent->isCancelled())
{
yg::Tile tile(tileTarget, frameScreen, m_currentCommand->m_rectInfo, duration);
yg::Tile tile(tileTarget, tileInfoLayer, frameScreen, m_currentCommand->m_rectInfo, duration);
m_renderQueue->TileCache().lock();
m_renderQueue->TileCache().addTile(m_currentCommand->m_rectInfo, yg::TileCache::Entry(tile, m_resourceManager));
m_renderQueue->TileCache().unlock();

80
yg/glyph_layout.cpp
View file

@ -12,6 +12,11 @@
namespace yg
{
void GlyphLayoutElem::transform(math::Matrix<double, 3, 3> const & m)
{
m_pt = m_pt * m;
}
double GlyphLayout::getKerning(GlyphLayoutElem const & prevElem, GlyphLayoutElem const & curElem)
{
double res = 0;
@ -56,17 +61,27 @@ namespace yg
return res;
}
GlyphLayout::GlyphLayout(GlyphLayout const & src, math::Matrix<double, 3, 3> const & m)
: m_firstVisible(src.m_firstVisible),
m_lastVisible(src.m_lastVisible),
m_pivot(src.m_pivot * m)
{
m_entries = src.m_entries;
/// TODO: it's better and faster to transform AARect, not calculate it once again.
computeMinLimitRect();
}
GlyphLayout::GlyphLayout(GlyphCache * glyphCache,
FontDesc const & fontDesc,
m2::PointD const & pt,
strings::UniString const & visText,
yg::EPosition pos)
: m_firstVisible(0),
m_lastVisible(visText.size())
m_lastVisible(visText.size()),
m_pivot(pt)
{
m2::PointD pv = pt;
m2::RectD limitRect;
m2::PointD curPt;
bool isFirst = true;
@ -77,26 +92,26 @@ namespace yg
GlyphMetrics const m = glyphCache->getGlyphMetrics(glyphKey);
if (isFirst)
{
limitRect = m2::RectD(m.m_xOffset + pv.x,
-m.m_yOffset + pv.y,
m.m_xOffset + pv.x,
-m.m_yOffset + pv.y);
limitRect = m2::RectD(m.m_xOffset,
-m.m_yOffset,
m.m_xOffset,
-m.m_yOffset);
isFirst = false;
}
else
limitRect.Add(m2::PointD(m.m_xOffset + pv.x, -m.m_yOffset + pv.y));
limitRect.Add(m2::PointD(m.m_xOffset + curPt.x, -m.m_yOffset + curPt.y));
limitRect.Add(m2::PointD(m.m_xOffset + m.m_width,
-(m.m_yOffset + m.m_height)) + pv);
-(m.m_yOffset + m.m_height)) + curPt);
GlyphLayoutElem elem;
elem.m_sym = visText[i];
elem.m_angle = 0;
elem.m_pt = pv;
elem.m_pt = curPt;
elem.m_metrics = m;
m_entries.push_back(elem);
pv += m2::PointD(m.m_xAdvance, m.m_yAdvance);
curPt += m2::PointD(m.m_xAdvance, m.m_yAdvance);
}
limitRect.Inflate(2, 2);
@ -118,12 +133,12 @@ namespace yg
m_limitRect = m2::AARectD(limitRect);
offset(ptOffs);
for (unsigned i = 0; i < m_entries.size(); ++i)
m_entries[i].m_pt += ptOffs;
m_limitRect.Offset(ptOffs);
}
GlyphLayout::GlyphLayout(GlyphCache * glyphCache,
FontDesc const & fontDesc,
m2::PointD const * pts,
@ -155,13 +170,24 @@ namespace yg
if (fullLength < strLength)
return;
PathPoint arrPathStart(0, ang::AngleD(ang::AngleTo(arrPath.get(0), arrPath.get(1))), arrPath.get(0));
m_pivot = arrPath.offsetPoint(arrPathStart, fullLength / 2.0).m_pt;
// offset of the text from path's start
double offset = (fullLength - strLength) / 2.0;
if (pos & yg::EPosLeft)
{
offset = 0;
m_pivot = arrPathStart.m_pt;
}
if (pos & yg::EPosRight)
{
offset = (fullLength - strLength);
m_pivot = arrPath.get(arrPath.size() - 1);
}
// calculate base line offset
double blOffset = 2 - fontDesc.m_size / 2;
@ -182,7 +208,7 @@ namespace yg
while (offset < 0 && symPos < count)
offset += m_entries[symPos++].m_metrics.m_xAdvance;
PathPoint glyphStartPt = arrPath.offsetPoint(PathPoint(0, ang::AngleD(ang::AngleTo(arrPath.get(0), arrPath.get(1))), arrPath.get(0)), offset);
PathPoint glyphStartPt = arrPath.offsetPoint(arrPathStart, offset);
m_firstVisible = symPos;
@ -268,7 +294,18 @@ namespace yg
m_lastVisible = symPos + 1;
}
/// storing glyph coordinates relative to pivot point.
for (unsigned i = m_firstVisible; i < m_lastVisible; ++i)
m_entries[i].m_pt -= m_pivot;
computeMinLimitRect();
// recalcPivot();
}
void GlyphLayout::recalcPivot()
{
}
void GlyphLayout::computeMinLimitRect()
@ -352,13 +389,16 @@ namespace yg
m2::AARectD const GlyphLayout::limitRect() const
{
return m_limitRect;
return m2::Offset(m_limitRect, pivot());
}
void GlyphLayout::offset(m2::PointD const & offs)
m2::PointD const & GlyphLayout::pivot() const
{
for (unsigned i = 0; i < m_entries.size(); ++i)
m_entries[i].m_pt += offs;
m_limitRect.Offset(offs);
return m_pivot;
}
void GlyphLayout::setPivot(m2::PointD const & pivot)
{
m_pivot = pivot;
}
}

11
yg/glyph_layout.hpp
View file

@ -26,6 +26,8 @@ namespace yg
GlyphMetrics m_metrics;
ang::AngleD m_angle;
m2::PointD m_pt;
void transform(math::Matrix<double, 3, 3> const & m);
};
class GlyphLayout
@ -39,12 +41,15 @@ namespace yg
m2::AARectD m_limitRect;
m2::PointD m_pivot;
double getKerning(GlyphLayoutElem const & prevElem, GlyphLayoutElem const & curElem);
void computeMinLimitRect();
void recalcPivot();
public:
GlyphLayout(GlyphLayout const & layout, double shift);
GlyphLayout(GlyphLayout const & layout, math::Matrix<double, 3, 3> const & m);
GlyphLayout(GlyphCache * glyphCache,
FontDesc const & font,
@ -68,6 +73,8 @@ namespace yg
m2::AARectD const limitRect() const;
void offset(m2::PointD const & offs);
m2::PointD const & pivot() const;
void setPivot(m2::PointD const & pv);
};
}

45
yg/info_layer.cpp
View file

@ -49,7 +49,7 @@ namespace yg
m_tree.ForEach(bind(&StraightTextElement::draw, _1, r, m));
}
template <typename Tree>
/* template <typename Tree>
void offsetTree(Tree & tree, m2::PointD const & offs, m2::RectD const & rect)
{
typedef typename Tree::elem_t elem_t;
@ -136,7 +136,7 @@ namespace yg
offsetTextTree(offs, rect);
offsetPathTexts(offs, rect);
offsetSymbols(offs, rect);
}
}*/
void InfoLayer::clear()
{
@ -145,17 +145,25 @@ namespace yg
m_symbolsMap.clear();
}
void InfoLayer::addStraightText(StraightTextElement const & ste)
void InfoLayer::addStraightTextImpl(StraightTextElement const & ste)
{
m_tree.ReplaceIf(ste, ste.boundRect().GetGlobalRect(), &better_text);
}
void InfoLayer::addStraightText(StraightTextElement const & ste, math::Matrix<double, 3, 3> const & m)
{
if (m == math::Identity<double, 3>())
addStraightTextImpl(ste);
else
addStraightTextImpl(StraightTextElement(ste, m));
}
void mark_intersect(bool & flag)
{
flag = true;
}
void InfoLayer::addSymbol(SymbolElement const & se)
void InfoLayer::addSymbolImpl(SymbolElement const & se)
{
bool isIntersect = false;
m2::RectD limitRect = se.boundRect().GetGlobalRect();
@ -164,7 +172,15 @@ namespace yg
m_symbolsMap[se.styleID()].Add(se, limitRect);
}
void InfoLayer::addPathText(PathTextElement const & pte)
void InfoLayer::addSymbol(SymbolElement const & se, math::Matrix<double, 3, 3> const & m)
{
if (m == math::Identity<double, 3>())
addSymbolImpl(se);
else
addSymbolImpl(SymbolElement(se, m));
}
void InfoLayer::addPathTextImpl(PathTextElement const & pte)
{
list<PathTextElement> & l = m_pathTexts[pte.logText()];
@ -180,5 +196,24 @@ namespace yg
if (doAppend)
l.push_back(pte);
}
void InfoLayer::addPathText(PathTextElement const & pte, math::Matrix<double, 3, 3> const & m)
{
/* if (m == math::Identity<double, 3>())
addPathTextImpl(pte);
else
addPathTextImpl(PathTextElement(pte, m));*/
}
void InfoLayer::merge(InfoLayer const & layer, math::Matrix<double, 3, 3> const & m)
{
for (symbols_map_t::const_iterator it = layer.m_symbolsMap.begin(); it != layer.m_symbolsMap.end(); ++it)
it->second.ForEach(bind(&InfoLayer::addSymbol, this, _1, m));
layer.m_tree.ForEach(bind(&InfoLayer::addStraightText, this, _1, m));
for (path_text_elements::const_iterator it = layer.m_pathTexts.begin(); it != layer.m_pathTexts.end(); ++it)
for_each(it->second.begin(), it->second.end(), bind(&InfoLayer::addPathText, this, _1, m));
}
}

20
yg/info_layer.hpp
View file

@ -7,6 +7,8 @@
#include "../geometry/point2d.hpp"
#include "../geometry/tree4d.hpp"
#include "../base/matrix.hpp"
#include "../std/map.hpp"
#include "../std/list.hpp"
@ -35,22 +37,28 @@ namespace yg
typedef map<uint32_t, m4::Tree<SymbolElement> > symbols_map_t;
symbols_map_t m_symbolsMap;
void offsetPathTexts(m2::PointD const & offs, m2::RectD const & rect);
/* void offsetPathTexts(m2::PointD const & offs, m2::RectD const & rect);
void offsetTextTree(m2::PointD const & offs, m2::RectD const & rect);
void offsetSymbols(m2::PointD const & offs, m2::RectD const & rect);
void offsetSymbols(m2::PointD const & offs, m2::RectD const & rect);*/
void addPathTextImpl(PathTextElement const & pte);
void addStraightTextImpl(StraightTextElement const & ste);
void addSymbolImpl(SymbolElement const & se);
public:
void draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m);
void addPathText(PathTextElement const & pte);
void addPathText(PathTextElement const & pte, math::Matrix<double, 3, 3> const & m);
void addStraightText(StraightTextElement const & ste);
void addStraightText(StraightTextElement const & ste, math::Matrix<double, 3, 3> const & m);
void addSymbol(SymbolElement const & se);
void addSymbol(SymbolElement const & se, math::Matrix<double, 3, 3> const & m);
void offset(m2::PointD const & offs, m2::RectD const & rect);
// void offset(m2::PointD const & offs, m2::RectD const & rect);
void clear();
void merge(InfoLayer const & infoLayer, math::Matrix<double, 3, 3> const & m);
};
}

4
yg/overlay_element.cpp
View file

@ -35,10 +35,10 @@ namespace yg
return res;
}
void OverlayElement::offset(m2::PointD const & offs)
/* void OverlayElement::offset(m2::PointD const & offs)
{
m_pivot += offs;
}
}*/
m2::PointD const & OverlayElement::pivot() const
{

3
yg/overlay_element.hpp
View file

@ -38,9 +38,8 @@ namespace yg
OverlayElement(Params const & p);
virtual void offset(m2::PointD const & offs) = 0;
virtual m2::AARectD const boundRect() const = 0;
virtual void draw(gl::OverlayRenderer * screen, math::Matrix<double, 3, 3> const & m) const = 0;
virtual void draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const = 0;
m2::PointD const & pivot() const;
void setPivot(m2::PointD const & pv);

38
yg/overlay_renderer.cpp
View file

@ -29,7 +29,7 @@ namespace yg
}
void OverlayRenderer::drawSymbol(m2::PointD const & pt,
uint32_t styleID,
string const & symbolName,
EPosition pos,
int depth)
{
@ -41,7 +41,8 @@ namespace yg
params.m_depth = depth;
params.m_position = pos;
params.m_pivot = pt;
params.m_styleID = styleID;
params.m_symbolName = symbolName;
params.m_styleID = 0;
params.m_skin = skin().get();
SymbolElement se(params);
@ -49,7 +50,7 @@ namespace yg
if (!m_infoLayer.get() || !m_useOverlay)
se.draw(this, math::Identity<double, 3>());
else
m_infoLayer->addSymbol(se);
m_infoLayer->addSymbol(se, math::Identity<double, 3>());
}
void OverlayRenderer::drawCircle(m2::PointD const & pt,
@ -65,7 +66,10 @@ namespace yg
params.m_skin = skin().get();
SymbolElement se(params);
se.draw(this, math::Identity<double, 3>());
math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
se.draw(this, id);
}
void OverlayRenderer::drawText(FontDesc const & fontDesc,
@ -89,10 +93,12 @@ namespace yg
StraightTextElement ste(params);
math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
if (!m_infoLayer.get() || !m_useOverlay)
ste.draw(this, math::Identity<double, 3>());
ste.draw(this, id);
else
m_infoLayer->addStraightText(ste);
m_infoLayer->addStraightText(ste, id);
}
bool OverlayRenderer::drawPathText(
@ -118,13 +124,29 @@ namespace yg
PathTextElement pte(params);
math::Matrix<double, 3, 3> id = math::Identity<double, 3>();
if (!m_infoLayer.get() || !m_useOverlay)
pte.draw(this, math::Identity<double, 3>());
pte.draw(this, id);
else
m_infoLayer->addPathText(pte);
m_infoLayer->addPathText(pte, id);
return true;
}
void OverlayRenderer::setInfoLayer(shared_ptr<InfoLayer> const & infoLayer)
{
m_infoLayer = infoLayer;
}
shared_ptr<InfoLayer> const & OverlayRenderer::infoLayer() const
{
return m_infoLayer;
}
void OverlayRenderer::resetInfoLayer()
{
m_infoLayer.reset();
}
}
}

8
yg/overlay_renderer.hpp
View file

@ -31,7 +31,7 @@ namespace yg
OverlayRenderer(Params const & p);
/// Drawing POI symbol
void drawSymbol(m2::PointD const & pt, uint32_t styleID, EPosition pos, int depth);
void drawSymbol(m2::PointD const & pt, string const & symbolName, EPosition pos, int depth);
/// Drawing circle
void drawCircle(m2::PointD const & pt, uint32_t styleID, EPosition pos, int depth);
@ -53,6 +53,12 @@ namespace yg
double pathOffset,
yg::EPosition pos,
double depth);
void setInfoLayer(shared_ptr<InfoLayer> const & infoLayer);
shared_ptr<InfoLayer> const & infoLayer() const;
void resetInfoLayer();
};
}
}

39
yg/symbol_element.cpp
View file

@ -10,19 +10,33 @@ namespace yg
{
SymbolElement::SymbolElement(Params const & p)
: OverlayElement(p),
m_styleID(p.m_styleID)
m_styleID(p.m_styleID),
m_symbolName(p.m_symbolName)
{
if (m_styleID == 0)
m_styleID = p.m_skin->mapSymbol(m_symbolName.c_str());
m_style = p.m_skin->fromID(m_styleID);
if (m_style == 0)
LOG(LINFO, ("drawSymbolImpl: styleID=", m_styleID, " wasn't found on the current skin"));
else
m_symbolRect = m_style->m_texRect;
}
SymbolElement::SymbolElement(SymbolElement const & se, math::Matrix<double, 3, 3> const & m)
: OverlayElement(se),
m_styleID(0),
m_style(0),
m_symbolName(se.m_symbolName),
m_symbolRect(se.m_symbolRect)
{
setPivot(se.pivot() * m);
}
m2::AARectD const SymbolElement::boundRect() const
{
if (m_style == 0)
return m2::AARectD();
m2::RectU texRect(m_style->m_texRect);
m2::RectU texRect = m_symbolRect;
texRect.Inflate(-1, -1);
m2::PointD posPt = tieRect(m2::RectD(texRect), math::Identity<double, 3>());
@ -30,16 +44,19 @@ namespace yg
return m2::RectD(posPt, posPt + m2::PointD(texRect.SizeX(), texRect.SizeY()));
}
void SymbolElement::offset(m2::PointD const & offs)
{
OverlayElement::offset(offs);
}
void SymbolElement::draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const
{
if (m_styleID == 0)
{
m_styleID = r->skin()->mapSymbol(m_symbolName.c_str());
m_style = r->skin()->fromID(m_styleID);
m_symbolRect = m_style->m_texRect;
}
if (m_style == 0)
return;
m2::RectU texRect(m_style->m_texRect);
m2::RectU texRect = m_symbolRect;
texRect.Inflate(-1, -1);
m2::PointD posPt = tieRect(m2::RectD(texRect), m);

9
yg/symbol_element.hpp
View file

@ -11,22 +11,25 @@ namespace yg
{
private:
uint32_t m_styleID;
ResourceStyle const * m_style;
mutable uint32_t m_styleID;
mutable ResourceStyle const * m_style;
string m_symbolName;
mutable m2::RectU m_symbolRect;
public:
struct Params : public OverlayElement::Params
{
Skin * m_skin;
string m_symbolName;
uint32_t m_styleID;
};
SymbolElement(Params const & p);
SymbolElement(SymbolElement const & se, math::Matrix<double, 3, 3> const & m);
m2::AARectD const boundRect() const;
void draw(gl::OverlayRenderer * s, math::Matrix<double, 3, 3> const & m) const;
void offset(m2::PointD const & offs);
uint32_t styleID() const;
};

38
yg/text_element.cpp
View file

@ -52,8 +52,7 @@ namespace yg
if ((layout.firstVisible() != 0) || (layout.lastVisible() != visText().size()))
return;
m2::PointD pivot = layout.entries()[0].m_pt;
m2::PointD offset = pivot * m - pivot;
m2::PointD pv = pivot() * m;
for (unsigned i = layout.firstVisible(); i < layout.lastVisible(); ++i)
{
@ -63,7 +62,7 @@ namespace yg
uint32_t const glyphID = skin->mapGlyph(glyphKey, screen->glyphCache());
CharStyle const * charStyle = static_cast<CharStyle const *>(skin->fromID(glyphID));
screen->drawGlyph(elem.m_pt + offset, m2::PointD(0.0, 0.0), elem.m_angle, 0, charStyle, depth);
screen->drawGlyph(elem.m_pt + pv, m2::PointD(0.0, 0.0), elem.m_angle, 0, charStyle, depth);
}
}
@ -75,11 +74,20 @@ namespace yg
visText(),
p.m_position)
{
setPivot(m_glyphLayout.pivot());
}
StraightTextElement::StraightTextElement(StraightTextElement const & src, math::Matrix<double, 3, 3> const & m)
: TextElement(src),
m_glyphLayout(src.m_glyphLayout)
{
m_glyphLayout.setPivot(m_glyphLayout.pivot() * m);
setPivot(m_glyphLayout.pivot());
}
m2::AARectD const StraightTextElement::boundRect() const
{
return m2::AARectD(m_glyphLayout.limitRect());
return m_glyphLayout.limitRect();
}
void StraightTextElement::draw(gl::OverlayRenderer * screen, math::Matrix<double, 3, 3> const & m) const
@ -97,12 +105,6 @@ namespace yg
drawTextImpl(m_glyphLayout, screen, m, desc, yg::maxDepth);
}
void StraightTextElement::offset(m2::PointD const & offs)
{
TextElement::offset(offs);
m_glyphLayout.offset(offs);
}
PathTextElement::PathTextElement(Params const & p)
: TextElement(p),
m_glyphLayout(p.m_glyphCache,
@ -114,11 +116,19 @@ namespace yg
p.m_pathOffset,
p.m_position)
{
setPivot(m_glyphLayout.pivot());
}
PathTextElement::PathTextElement(PathTextElement const & src, math::Matrix<double, 3, 3> const & m)
: TextElement(src),
m_glyphLayout(src.m_glyphLayout, m)
{
setPivot(m_glyphLayout.pivot());
}
m2::AARectD const PathTextElement::boundRect() const
{
return m2::Inflate(m_glyphLayout.limitRect(), m2::PointD(40, 2));
return m2::Inflate(m_glyphLayout.limitRect(), m2::PointD(40, 2)); //< to create more sparse street names structure
}
void PathTextElement::draw(gl::OverlayRenderer * screen, math::Matrix<double, 3, 3> const & m) const
@ -132,10 +142,4 @@ namespace yg
drawTextImpl(m_glyphLayout, screen, m, desc, yg::maxDepth);
}
void PathTextElement::offset(m2::PointD const & offs)
{
TextElement::offset(offs);
m_glyphLayout.offset(offs);
}
}

5
yg/text_element.hpp
View file

@ -61,6 +61,7 @@ namespace yg
{
private:
/// glyph layout aligned to pivot point
GlyphLayout m_glyphLayout;
public:
@ -69,10 +70,10 @@ namespace yg
{};
StraightTextElement(Params const & p);
StraightTextElement(StraightTextElement const & src, math::Matrix<double, 3, 3> const & m);
m2::AARectD const boundRect() const;
void draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
void offset(m2::PointD const & offs);
};
class PathTextElement : public TextElement
@ -92,9 +93,9 @@ namespace yg
};
PathTextElement(Params const & p);
PathTextElement(PathTextElement const & src, math::Matrix<double, 3, 3> const & m);
m2::AARectD const boundRect() const;
void draw(gl::OverlayRenderer * r, math::Matrix<double, 3, 3> const & m) const;
void offset(m2::PointD const & offs);
};
}

5
yg/tile.hpp
View file

@ -8,9 +8,12 @@
namespace yg
{
class InfoLayer;
struct Tile
{
shared_ptr<gl::BaseTexture> m_renderTarget; //< taken from resource manager
shared_ptr<InfoLayer> m_infoLayer; //< text and POI's
ScreenBase m_tileScreen; //< cached to calculate it once, cause tile blitting
//< is performed on GUI thread.
Tiler::RectInfo m_rectInfo; //< taken from tiler
@ -20,10 +23,12 @@ namespace yg
{}
Tile(shared_ptr<gl::BaseTexture> const & renderTarget,
shared_ptr<InfoLayer> const & infoLayer,
ScreenBase const & tileScreen,
Tiler::RectInfo const & rectInfo,
double duration)
: m_renderTarget(renderTarget),
m_infoLayer(infoLayer),
m_tileScreen(tileScreen),
m_rectInfo(rectInfo),
m_duration(duration)

2
yg/yg_tests/screengl_test.cpp
View file

@ -1227,7 +1227,7 @@ namespace
void DoDraw(shared_ptr<yg::gl::Screen> const & p)
{
for (int i = 0; i < 40; ++i)
p->drawSymbol(m2::PointD(100 + i, 100), p->skin()->mapSymbol("hospital"), yg::EPosCenter, 0);
p->drawSymbol(m2::PointD(100 + i, 100), "hospital", yg::EPosCenter, 0);
}
};