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

removed static font usage. refactored text rendering code to use separate glyph caches for rendering in different threads.

Browse source
This commit is contained in:
rachytski 2011-06-12 21:04:25 +03:00 • committed by Alex Zolotarev
parent 9e73efd602
commit 01de4ae2f3
22 changed files with 126 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
map/drawer_yg.cpp
View file

@ -246,7 +246,7 @@ void DrawerYG::drawText(m2::PointD const & pt, di::DrawInfo const * pInfo, rule_
// bool isMasked = pRule->GetColor() != -1;
bool isMasked = true;
yg::FontDesc fontDesc(false, get_text_font_size(pRule), textColor, isMasked, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(get_text_font_size(pRule), textColor, isMasked, yg::Color(255, 255, 255, 255));
fontDesc.SetRank(pInfo->m_rank);
if (!filter_text_size(pRule))
@ -264,7 +264,7 @@ bool DrawerYG::drawPathText(di::PathInfo const & info, string const & name, uint
{
// bool const isMasked = (double(fontSize) / m_visualScale >= min_text_height);
yg::FontDesc fontDesc(false, fontSize);
yg::FontDesc fontDesc(fontSize);
return m_pScreen->drawPathText( fontDesc,
&info.m_path[0],
@ -290,7 +290,6 @@ void DrawerYG::drawPathNumber(di::PathInfo const & path, di::DrawInfo const * pI
if (path.GetSmPoint(double(j) / double(count), pt))
{
yg::FontDesc fontDesc(
false,
textHeight,
yg::Color(150, 75, 0, 255), // brown
true,

2
map/framework.cpp
View file

@ -787,7 +787,7 @@ void FrameWork<TModel>::AddRedrawCommandSure()
int scaleLevel
)
{
fwork::DrawProcessor doDraw(selectRect, screen, e, scaleLevel, m_renderQueue.renderStatePtr(), m_resourceManager->getGlyphCache());
fwork::DrawProcessor doDraw(selectRect, screen, e, scaleLevel, m_renderQueue.renderStatePtr(), e->drawer()->screen()->glyphCache());
m_renderQueue.renderStatePtr()->m_isEmptyModelCurrent = true;
try

13
map/information_display.cpp
View file

@ -31,8 +31,8 @@ InformationDisplay::InformationDisplay()
for (int i = 0; i < sizeof(m_DebugPts) / sizeof(m2::PointD); ++i)
m_DebugPts[i] = m2::PointD(0, 0);
m_fontDesc = yg::FontDesc(false, 12);
m_emptyMessageFont = yg::FontDesc(false, 14);
m_fontDesc = yg::FontDesc(12);
m_emptyMessageFont = yg::FontDesc(14);
}
void InformationDisplay::setScreen(ScreenBase const & screen)
@ -220,8 +220,7 @@ void InformationDisplay::drawCenter(DrawerYG * drawer)
params.m_pivot = m2::PointD(m_displayRect.maxX() - 10 * m_visualScale,
m_displayRect.maxY() - (m_bottomShift + 10) * m_visualScale - 5);
params.m_position = yg::EPosAboveLeft;
params.m_rm = drawer->screen()->resourceManager().get();
params.m_skin = drawer->screen()->skin().get();
params.m_glyphCache = drawer->screen()->glyphCache();
params.m_logText = strings::MakeUniString(out.str());
yg::StraightTextElement ste(params);
@ -389,8 +388,7 @@ void InformationDisplay::drawLog(DrawerYG * drawer)
params.m_log2vis = false;
params.m_pivot = startPt;
params.m_position = yg::EPosAboveRight;
params.m_rm = drawer->screen()->resourceManager().get();
params.m_skin = drawer->screen()->skin().get();
params.m_glyphCache = drawer->screen()->glyphCache();
params.m_logText = strings::MakeUniString(*it);
yg::StraightTextElement ste(params);
@ -428,8 +426,7 @@ void InformationDisplay::drawEmptyModelMessage(DrawerYG * pDrawer)
params.m_log2vis = false;
params.m_pivot = pt;
params.m_position = yg::EPosCenter;
params.m_rm = pDrawer->screen()->resourceManager().get();
params.m_skin = pDrawer->screen()->skin().get();
params.m_glyphCache = pDrawer->screen()->glyphCache();
params.m_logText = strings::FromUtf8(s0);
params.m_utf8Text = s0;

1
map/render_queue_routine.cpp
View file

@ -239,6 +239,7 @@ void RenderQueueRoutine::Do()
params.m_renderState = m_renderState;
params.m_doPeriodicalUpdate = m_doPeriodicalUpdate;
params.m_updateInterval = m_updateInterval;
params.m_glyphCacheID = 1;
/* params.m_isDebugging = true;
params.m_drawPathes = false;
params.m_drawAreas = false;

11
yg/font_desc.cpp
View file

@ -10,9 +10,9 @@ namespace yg
{
FontDesc const & FontDesc::defaultFont = FontDesc();
FontDesc::FontDesc(bool isStatic, int size, yg::Color const & color,
FontDesc::FontDesc(int size, yg::Color const & color,
bool isMasked, yg::Color const & maskColor)
: m_isStatic(isStatic), m_size(size), m_color(color),
: m_size(size), m_color(color),
m_isMasked(isMasked), m_maskColor(maskColor)
{}
@ -24,8 +24,7 @@ namespace yg
bool FontDesc::operator ==(FontDesc const & src) const
{
return (m_isStatic == src.m_isStatic)
&& (m_size == src.m_size)
return (m_size == src.m_size)
&& (m_color == src.m_color)
&& (m_isMasked == src.m_isMasked)
&& (m_maskColor == src.m_maskColor);
@ -38,8 +37,6 @@ namespace yg
bool FontDesc::operator < (FontDesc const & src) const
{
if (m_isStatic != src.m_isStatic)
return m_isStatic < src.m_isStatic;
if (m_size != src.m_size)
return m_size < src.m_size;
if (m_color != src.m_color)
@ -53,8 +50,6 @@ namespace yg
bool FontDesc::operator > (FontDesc const & src) const
{
if (m_isStatic != src.m_isStatic)
return m_isStatic > src.m_isStatic;
if (m_size != src.m_size)
return m_size > src.m_size;
if (m_color != src.m_color)

3
yg/font_desc.hpp
View file

@ -6,13 +6,12 @@ namespace yg
{
struct FontDesc
{
bool m_isStatic;
int m_size;
yg::Color m_color;
bool m_isMasked;
yg::Color m_maskColor;
FontDesc(bool isStatic = true, int size = 10, yg::Color const & color = yg::Color(0, 0, 0, 255),
FontDesc(int size = 10, yg::Color const & color = yg::Color(0, 0, 0, 255),
bool isMasked = true, yg::Color const & maskColor = yg::Color(255, 255, 255, 255));
void SetRank(double rank);

5
yg/glyph_cache.cpp
View file

@ -45,6 +45,9 @@ namespace yg
: m_blocksFile(blocksFile), m_whiteListFile(whiteListFile), m_blackListFile(blackListFile), m_maxSize(maxSize)
{}
GlyphCache::GlyphCache()
{}
GlyphCache::GlyphCache(Params const & params) : m_impl(new GlyphCacheImpl(params))
{
}
@ -153,7 +156,7 @@ namespace yg
return m;
}
shared_ptr<GlyphInfo> const GlyphCache::getGlyph(GlyphKey const & key)
shared_ptr<GlyphInfo> const GlyphCache::getGlyphInfo(GlyphKey const & key)
{
pair<Font *, int> charIDX = getCharIDX(key);

3
yg/glyph_cache.hpp
View file

@ -67,6 +67,7 @@ namespace yg
Params(char const * blocksFile, char const * whiteListFile, char const * blackListFile, size_t maxSize);
};
GlyphCache();
GlyphCache(Params const & params);
void reset();
@ -75,7 +76,7 @@ namespace yg
pair<Font*, int> getCharIDX(GlyphKey const & key);
shared_ptr<GlyphInfo> const getGlyph(GlyphKey const & key);
shared_ptr<GlyphInfo> const getGlyphInfo(GlyphKey const & key);
/// return control box(could be slightly larger than the precise bound box).
GlyphMetrics const getGlyphMetrics(GlyphKey const & key);

81
yg/glyph_layout.cpp
View file

@ -1,6 +1,4 @@
#include "glyph_layout.hpp"
#include "resource_manager.hpp"
#include "skin.hpp"
#include "font_desc.hpp"
#include "resource_style.hpp"
#include "text_path.hpp"
@ -58,8 +56,7 @@ namespace yg
return res;
}
GlyphLayout::GlyphLayout(ResourceManager * resourceManager,
Skin * skin,
GlyphLayout::GlyphLayout(GlyphCache * glyphCache,
FontDesc const & fontDesc,
m2::PointD const & pt,
strings::UniString const & visText,
@ -77,67 +74,29 @@ namespace yg
{
GlyphKey glyphKey(visText[i], fontDesc.m_size, fontDesc.m_isMasked, fontDesc.m_color);
if (fontDesc.m_isStatic)
GlyphMetrics const m = glyphCache->getGlyphMetrics(glyphKey);
if (isFirst)
{
uint32_t glyphID = skin->mapGlyph(glyphKey, fontDesc.m_isStatic);
CharStyle const * p = static_cast<CharStyle const *>(skin->fromID(glyphID));
if (p != 0)
{
if (isFirst)
{
limitRect = m2::RectD(p->m_xOffset + pv.x,
-p->m_yOffset + pv.y,
p->m_xOffset + pv.x,
-p->m_yOffset + pv.y);
isFirst = false;
}
else
limitRect.Add(m2::PointD(p->m_xOffset, -p->m_yOffset) + pv);
limitRect.Add(m2::PointD(p->m_xOffset + p->m_texRect.SizeX() - 4,
-(p->m_yOffset + (int)p->m_texRect.SizeY() - 4)) + pv);
}
GlyphLayoutElem elem;
elem.m_sym = visText[i];
elem.m_angle = 0;
elem.m_pt = pv;
elem.m_metrics.m_height = p ? p->m_texRect.SizeY() - 4 : 0;
elem.m_metrics.m_width = p ? p->m_texRect.SizeX() - 4 : 0;
elem.m_metrics.m_xAdvance = p ? p->m_xAdvance : 0;
elem.m_metrics.m_xOffset = p ? p->m_xOffset : 0;
elem.m_metrics.m_yOffset = p ? p->m_yOffset : 0;
elem.m_metrics.m_yAdvance = 0;
m_entries.push_back(elem);
pv += m2::PointD(p ? p->m_xAdvance : 0, 0);
limitRect = m2::RectD(m.m_xOffset + pv.x,
-m.m_yOffset + pv.y,
m.m_xOffset + pv.x,
-m.m_yOffset + pv.y);
isFirst = false;
}
else
{
GlyphMetrics const m = resourceManager->getGlyphMetrics(glyphKey);
if (i == 0)
limitRect = m2::RectD(m.m_xOffset + pv.x,
-m.m_yOffset + pv.y,
m.m_xOffset + pv.x,
-m.m_yOffset + pv.y);
else
limitRect.Add(m2::PointD(m.m_xOffset, -m.m_yOffset) + pv);
limitRect.Add(m2::PointD(m.m_xOffset + pv.x, -m.m_yOffset + pv.y));
limitRect.Add(m2::PointD(m.m_xOffset + m.m_width,
-(m.m_yOffset + m.m_height)) + pv);
limitRect.Add(m2::PointD(m.m_xOffset + m.m_width,
-(m.m_yOffset + m.m_height)) + pv);
GlyphLayoutElem elem;
elem.m_sym = visText[i];
elem.m_angle = 0;
elem.m_pt = pv;
elem.m_metrics = m;
m_entries.push_back(elem);
GlyphLayoutElem elem;
elem.m_sym = visText[i];
elem.m_angle = 0;
elem.m_pt = pv;
elem.m_metrics = m;
m_entries.push_back(elem);
pv += m2::PointD(m.m_xAdvance, m.m_yAdvance);
}
pv += m2::PointD(m.m_xAdvance, m.m_yAdvance);
}
limitRect.Inflate(2, 2);
@ -165,7 +124,7 @@ namespace yg
}
GlyphLayout::GlyphLayout(ResourceManager * resourceManager,
GlyphLayout::GlyphLayout(GlyphCache * glyphCache,
FontDesc const & fontDesc,
m2::PointD const * pts,
size_t ptsCount,
@ -188,7 +147,7 @@ namespace yg
for (size_t i = 0; i < m_entries.size(); ++i)
{
m_entries[i].m_sym = visText[i];
m_entries[i].m_metrics = resourceManager->getGlyphMetrics(GlyphKey(m_entries[i].m_sym, fontDesc.m_size, fontDesc.m_isMasked, yg::Color(0, 0, 0, 0)));
m_entries[i].m_metrics = glyphCache->getGlyphMetrics(GlyphKey(m_entries[i].m_sym, fontDesc.m_size, fontDesc.m_isMasked, yg::Color(0, 0, 0, 0)));
strLength += m_entries[i].m_metrics.m_xAdvance;
}

8
yg/glyph_layout.hpp
View file

@ -17,8 +17,7 @@
namespace yg
{
class ResourceManager;
class Skin;
class GlyphCache;
struct FontDesc;
struct GlyphLayoutElem
@ -47,14 +46,13 @@ namespace yg
GlyphLayout(GlyphLayout const & layout, double shift);
GlyphLayout(ResourceManager * resourceManager,
Skin * skin,
GlyphLayout(GlyphCache * glyphCache,
FontDesc const & font,
m2::PointD const & pt,
strings::UniString const & visText,
yg::EPosition pos);
GlyphLayout(ResourceManager * resourceManager,
GlyphLayout(GlyphCache * glyphCache,
FontDesc const & font,
m2::PointD const * pts,
size_t ptsCount,

24
yg/resource_manager.cpp
View file

@ -31,11 +31,16 @@ namespace yg
m_vbSize(vbSize), m_ibSize(ibSize),
m_smallVBSize(smallVBSize), m_smallIBSize(smallIBSize),
m_blitVBSize(blitVBSize), m_blitIBSize(blitIBSize),
m_glyphCache(GlyphCache::Params(blocksFile, whiteListFile, blackListFile, maxGlyphCacheSize)),
m_format(fmt),
m_useVA(useVA),
m_fillSkinAlpha(fillSkinAlpha)
{
/// primary cache is for rendering, so it's big
m_glyphCaches.push_back(GlyphCache(GlyphCache::Params(blocksFile, whiteListFile, blackListFile, maxGlyphCacheSize)));
/// secondary caches is for glyph metrics only, so they are small
m_glyphCaches.push_back(GlyphCache(GlyphCache::Params(blocksFile, whiteListFile, blackListFile, 500 * 1024)));
if (useVA)
{
LOG(LINFO, ("buffer objects are unsupported. using client vertex array instead."));
@ -197,24 +202,15 @@ namespace yg
}
}
shared_ptr<GlyphInfo> const ResourceManager::getGlyphInfo(GlyphKey const & key)
GlyphCache * ResourceManager::glyphCache(int glyphCacheID)
{
return m_glyphCache.getGlyph(key);
}
GlyphMetrics const ResourceManager::getGlyphMetrics(GlyphKey const & key)
{
return m_glyphCache.getGlyphMetrics(key);
}
GlyphCache * ResourceManager::getGlyphCache()
{
return &m_glyphCache;
return &m_glyphCaches[glyphCacheID];
}
void ResourceManager::addFonts(vector<string> const & fontNames)
{
m_glyphCache.addFonts(fontNames);
for (unsigned i = 0; i < m_glyphCaches.size(); ++i)
m_glyphCaches[i].addFonts(fontNames);
}
void ResourceManager::memoryWarning()

4
yg/resource_manager.hpp
View file

@ -59,7 +59,7 @@ namespace yg
gl::Storage const reserveStorageImpl(bool doWait, list<gl::Storage> & l);
void freeStorageImpl(gl::Storage const & storage, bool doSignal, list<gl::Storage> & l);
GlyphCache m_glyphCache;
vector<GlyphCache> m_glyphCaches;
RtFormat m_format;
@ -96,7 +96,7 @@ namespace yg
shared_ptr<GlyphInfo> const getGlyphInfo(GlyphKey const & key);
GlyphMetrics const getGlyphMetrics(GlyphKey const & key);
GlyphCache * getGlyphCache();
GlyphCache * glyphCache(int glyphCacheID = 0);
void addFonts(vector<string> const & fontNames);

11
yg/skin.cpp
View file

@ -180,24 +180,21 @@ namespace yg
return true;
}
uint32_t Skin::mapGlyph(GlyphKey const & gk, bool isFixedFont)
uint32_t Skin::mapGlyph(GlyphKey const & gk, GlyphCache * glyphCache)
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
{
res = m_pages[i]->findGlyph(gk, isFixedFont);
res = m_pages[i]->findGlyph(gk);
if (res != invalidPageHandle())
return packID(i, res);
}
if (isFixedFont)
return res;
if (!m_pages[m_currentTextPage]->hasRoom(gk))
if (!m_pages[m_currentTextPage]->hasRoom(gk, glyphCache))
changeCurrentTextPage();
return packID(m_currentTextPage, m_pages[m_currentTextPage]->mapGlyph(gk));
return packID(m_currentTextPage, m_pages[m_currentTextPage]->mapGlyph(gk, glyphCache));
}
Skin::TSkinPages const & Skin::pages() const

3
yg/skin.hpp
View file

@ -32,6 +32,7 @@ namespace yg
struct CircleInfo;
struct Color;
struct GlyphKey;
class GlyphCache;
struct FontInfo;
class Skin
@ -126,7 +127,7 @@ namespace yg
/// find glyph identified by GlyphKey on texture
/// if found - return id
/// if not - pack and return id
uint32_t mapGlyph(GlyphKey const & gk, bool isFixedFont);
uint32_t mapGlyph(GlyphKey const & gk, GlyphCache * glyphCache);
/// find circleStyle on texture
/// if found - return id
/// if not - pack and return id

44
yg/skin_page.cpp
View file

@ -203,40 +203,8 @@ namespace yg
return it->second;
}
uint32_t SkinPage::findGlyph(GlyphKey const & g, bool isFixedFont) const
uint32_t SkinPage::findGlyph(GlyphKey const & g) const
{
if (isFixedFont)
{
TStyles::const_iterator styleIt = m_styles.find(g.toUInt32());
if (styleIt != m_styles.end())
return g.toUInt32();
TFonts::const_iterator fontIt = m_fonts.begin();
int lastFontSize = 0;
if (!m_fonts.empty())
lastFontSize = m_fonts[0].m_fontSize;
for (TFonts::const_iterator it = m_fonts.begin(); it != m_fonts.end(); ++it)
if ((lastFontSize < g.m_fontSize) && (g.m_fontSize >= it->m_fontSize))
fontIt = it;
else
lastFontSize = it->m_fontSize;
if (fontIt != m_fonts.end())
{
FontInfo::TChars::const_iterator charIt = fontIt->m_chars.find(g.m_symbolCode);
if (charIt != fontIt->m_chars.end())
{
if (g.m_isMask)
const_cast<TStyles&>(m_styles)[g.toUInt32()] = charIt->second.second;
else
const_cast<TStyles&>(m_styles)[g.toUInt32()]= charIt->second.first;
return g.toUInt32();
}
}
return m_packer.invalidHandle();
}
TGlyphMap::const_iterator it = m_glyphMap.find(g);
if (it == m_glyphMap.end())
return m_packer.invalidHandle();
@ -244,13 +212,13 @@ namespace yg
return it->second;
}
uint32_t SkinPage::mapGlyph(yg::GlyphKey const & g)
uint32_t SkinPage::mapGlyph(yg::GlyphKey const & g, yg::GlyphCache * glyphCache)
{
uint32_t foundHandle = findGlyph(g, false);
uint32_t foundHandle = findGlyph(g);
if (foundHandle != m_packer.invalidHandle())
return foundHandle;
shared_ptr<GlyphInfo> gi = m_resourceManager->getGlyphInfo(g);
shared_ptr<GlyphInfo> gi = glyphCache->getGlyphInfo(g);
m2::Packer::handle_t handle = m_packer.pack(gi->m_metrics.m_width + 4,
gi->m_metrics.m_height + 4);
@ -269,9 +237,9 @@ namespace yg
return m_glyphMap[g];
}
bool SkinPage::hasRoom(GlyphKey const & gk) const
bool SkinPage::hasRoom(GlyphKey const & gk, GlyphCache * glyphCache) const
{
shared_ptr<GlyphInfo> gi = m_resourceManager->getGlyphInfo(gk);
shared_ptr<GlyphInfo> gi = glyphCache->getGlyphInfo(gk);
return m_packer.hasRoom(gi->m_metrics.m_width + 4, gi->m_metrics.m_height + 4);
}

6
yg/skin_page.hpp
View file

@ -165,9 +165,9 @@ namespace yg
uint32_t mapCircleInfo(CircleInfo const & circleInfo);
bool hasRoom(CircleInfo const & circleInfo) const;
uint32_t findGlyph(GlyphKey const & g, bool isFixedFont) const;
uint32_t mapGlyph(GlyphKey const & g);
bool hasRoom(GlyphKey const & g) const;
uint32_t findGlyph(GlyphKey const & g) const;
uint32_t mapGlyph(GlyphKey const & g, GlyphCache * glyphCache);
bool hasRoom(GlyphKey const & g, GlyphCache * glyphCache) const;
uint32_t findSymbol(char const * symbolName) const;

12
yg/text_element.cpp
View file

@ -63,8 +63,7 @@ namespace yg
m_fontDesc(p.m_fontDesc),
m_logText(p.m_logText),
m_log2vis(p.m_log2vis),
m_rm(p.m_rm),
m_skin(p.m_skin),
m_glyphCache(p.m_glyphCache),
m_utf8Text(p.m_utf8Text)
{
if (m_log2vis)
@ -103,10 +102,10 @@ namespace yg
for (unsigned i = layout.firstVisible(); i < layout.lastVisible(); ++i)
{
shared_ptr<Skin> const & skin = screen->skin();
Skin * skin = screen->skin().get();
GlyphLayoutElem const & elem = layout.entries()[i];
GlyphKey glyphKey(elem.m_sym, fontDesc.m_size, fontDesc.m_isMasked, fontDesc.m_isMasked ? fontDesc.m_maskColor : fontDesc.m_color);
uint32_t const glyphID = skin->mapGlyph(glyphKey, fontDesc.m_isStatic);
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);
@ -115,8 +114,7 @@ namespace yg
StraightTextElement::StraightTextElement(Params const & p)
: TextElement(p),
m_glyphLayout(p.m_rm,
p.m_skin,
m_glyphLayout(p.m_glyphCache,
p.m_fontDesc,
p.m_pivot,
visText(),
@ -154,7 +152,7 @@ namespace yg
PathTextElement::PathTextElement(Params const & p)
: TextElement(p),
m_glyphLayout(p.m_rm,
m_glyphLayout(p.m_glyphCache,
p.m_fontDesc,
p.m_pts,
p.m_ptsCount,

17
yg/text_element.hpp
View file

@ -67,8 +67,7 @@ namespace yg
strings::UniString m_logText; //< logical string
strings::UniString m_visText; //< visual string, BIDI processed
bool m_log2vis;
ResourceManager * m_rm;
Skin * m_skin;
GlyphCache * m_glyphCache;
strings::UniString log2vis(strings::UniString const & str);
@ -79,15 +78,19 @@ namespace yg
FontDesc m_fontDesc;
wstring m_logText;
bool m_log2vis;
ResourceManager * m_rm;
Skin * m_skin;
GlyphCache * m_glyphCache;
};
TextElement(Params const & p);
void drawTextImpl(GlyphLayout const & layout, gl::TextRenderer * screen, FontDesc const & desc, double depth) const;
strings::UniString const & logText() const;
strings::UniString const & visText() const;
void drawTextImpl(GlyphLayout const & layout,
gl::TextRenderer * screen,
math::Matrix<double, 3, 3> const & m,
FontDesc const & desc,
double depth) const;
wstring const & logText() const;
wstring const & visText() const;
string const & utf8Text() const;
FontDesc const & fontDesc() const;
};

23
yg/text_renderer.cpp
View file

@ -17,12 +17,14 @@ namespace yg
{
TextRenderer::Params::Params()
: m_drawTexts(true)
: m_drawTexts(true),
m_glyphCacheID(0)
{}
TextRenderer::TextRenderer(Params const & params)
: base_t(params),
m_drawTexts(params.m_drawTexts)
m_drawTexts(params.m_drawTexts),
m_glyphCacheID(params.m_glyphCacheID)
{}
void TextRenderer::drawText(FontDesc const & fontDesc,
@ -42,13 +44,12 @@ namespace yg
params.m_log2vis = log2vis;
params.m_pivot = pt;
params.m_position = pos;
params.m_rm = resourceManager().get();
params.m_skin = skin().get();
params.m_glyphCache = resourceManager()->glyphCache(m_glyphCacheID);
params.m_logText = strings::MakeUniString(utf8Text);
StraightTextElement ste(params);
if (!renderState().get() || fontDesc.m_isStatic)
if (!renderState().get())
ste.draw(this, math::Identity<double, 3>());
else
renderState()->m_currentInfoLayer->addStraightText(ste);
@ -71,14 +72,13 @@ namespace yg
params.m_logText = strings::FromUtf8(utf8Text);
params.m_depth = depth;
params.m_log2vis = true;
params.m_rm = resourceManager().get();
params.m_skin = skin().get();
params.m_glyphCache = resourceManager()->glyphCache(m_glyphCacheID);
params.m_pivot = path[0];
params.m_position = pos;
PathTextElement pte(params);
if (!renderState().get() || fontDesc.m_isStatic)
if (!renderState().get())
pte.draw(this, math::Identity<double, 3>());
else
renderState()->m_currentInfoLayer->addPathText(pte);
@ -102,5 +102,10 @@ namespace yg
depth,
p->m_pageID);
}
GlyphCache * TextRenderer::glyphCache() const
{
return resourceManager()->glyphCache(m_glyphCacheID);
}
}
}

4
yg/text_renderer.hpp
View file

@ -37,6 +37,7 @@ namespace yg
bool log2vis);
bool m_drawTexts;
int m_glyphCacheID;
public:
@ -45,6 +46,7 @@ namespace yg
struct Params : base_t::Params
{
bool m_drawTexts;
int m_glyphCacheID;
Params();
};
@ -75,6 +77,8 @@ namespace yg
double pathOffset,
yg::EPosition pos,
double depth);
GlyphCache * glyphCache() const;
};
}
}

4
yg/yg_tests/glyph_cache_test.cpp
View file

@ -14,8 +14,8 @@ UNIT_TEST(GlyphCacheTest_Main)
200000));
cache.addFont((path + "01_dejavusans.ttf").c_str());
shared_ptr<yg::GlyphInfo> g1 = cache.getGlyph(yg::GlyphKey('#', 40, true, yg::Color(255, 255, 255, 255)));
shared_ptr<yg::GlyphInfo> g1 = cache.getGlyphInfo(yg::GlyphKey('#', 40, true, yg::Color(255, 255, 255, 255)));
// g1->dump(GetPlatform().WritablePathForFile("#_mask.png").c_str());
shared_ptr<yg::GlyphInfo> g2 = cache.getGlyph(yg::GlyphKey('#', 40, false, yg::Color(0, 0, 0, 0)));
shared_ptr<yg::GlyphInfo> g2 = cache.getGlyphInfo(yg::GlyphKey('#', 40, false, yg::Color(0, 0, 0, 0)));
// g2->dump(GetPlatform().WritablePathForFile("#.png").c_str());
}

80
yg/yg_tests/screengl_test.cpp
View file

@ -598,7 +598,7 @@ namespace
double pat[2] = {2, 2};
p->drawPath(path, sizeof(path) / sizeof(m2::PointD), 0, p->skin()->mapPenInfo(yg::PenInfo(yg::Color(0, 0, 0, 0xFF), 2, pat, 2, 0)), 0);
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(200, 200), yg::EPosAboveRight, 0 , "0", 0, true);
p->drawText(fontDesc, m2::PointD(240, 200), yg::EPosAboveRight, math::pi / 2 , "0", 0, true);
@ -613,7 +613,7 @@ namespace
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0, "X", 1, true);
}
};
@ -622,7 +622,7 @@ namespace
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0, " ", 1, true);
}
};
@ -634,7 +634,7 @@ namespace
size_t const maxTimes = 10;
size_t const yStep = 30;
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
for (size_t i = 0; i < maxTimes; ++i)
for (size_t j = 1; j <= i+1; ++j)
@ -654,7 +654,7 @@ namespace
yg::PenInfo penInfo = yg::PenInfo(yg::Color(0, 0, 0, 0xFF), 2, &pat[0], ARRAY_SIZE(pat), 0);
yg::PenInfo solidPenInfo = yg::PenInfo(yg::Color(0xFF, 0, 0, 0xFF), 4, 0, 0, 0);
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0, "S", 0, true);
p->drawPath(&path[0], path.size(), 0, p->skin()->mapPenInfo(solidPenInfo), 0);
@ -666,24 +666,16 @@ namespace
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0/*, math::pi / 18*/, "Simplicity is the ultimate sophistication", 0, true);
}
};
struct TestDrawStringWithFixedFont
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
p->drawText(yg::FontDesc::defaultFont, m2::PointD(40, 50), yg::EPosAboveRight, 0/*, math::pi / 18*/, "Simplicity is the ultimate sophistication", 0, true);
}
};
struct TestDrawStringWithColor
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::FontDesc fontDesc(false, 25, yg::Color(0, 0, 255, 255), true, yg::Color(255, 255, 255, 255));
yg::FontDesc fontDesc(25, yg::Color(0, 0, 255, 255), true, yg::Color(255, 255, 255, 255));
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0/*, math::pi / 18*/, "Simplicity is the ultimate sophistication", 0, true);
}
};
@ -693,7 +685,7 @@ namespace
{
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::FontDesc fontDesc(false, 12);
yg::FontDesc fontDesc(12);
p->drawText(fontDesc, m2::PointD(40, 50), yg::EPosAboveRight, 0, "Latin Symbol : A", 0, true);
p->drawText(fontDesc, m2::PointD(40, 80), yg::EPosAboveRight, 0, "Cyrillic Symbol : Ы", 0, true);
}
@ -708,36 +700,11 @@ namespace
yg::StraightTextElement::Params params;
params.m_depth = 0;
params.m_fontDesc = yg::FontDesc(false, 20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
params.m_fontDesc = yg::FontDesc(20, yg::Color(0, 0, 0, 0), true, yg::Color(255, 255, 255, 255));
params.m_log2vis = false;
params.m_pivot = startPt;
params.m_position = yg::EPosAboveRight;
params.m_rm = p->resourceManager().get();
params.m_skin = p->skin().get();
params.m_logText = strings::MakeUniString("Simplicity is the ultimate sophistication");
yg::StraightTextElement ste(params);
m2::AARectD r = ste.boundRect();
p->drawRectangle(r, yg::Color(0, 0, 255, 255), 0);
base_t::DoDraw(p);
}
};
struct TestDrawTextRectWithFixedFont : TestDrawStringWithFixedFont
{
typedef TestDrawStringWithFixedFont base_t;
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
m2::PointD startPt(40, 50);
yg::StraightTextElement::Params params;
params.m_depth = 0;
params.m_fontDesc = yg::FontDesc::defaultFont;
params.m_log2vis = false;
params.m_pivot = startPt;
params.m_position = yg::EPosAboveRight;
params.m_rm = p->resourceManager().get();
params.m_skin = p->skin().get();
params.m_glyphCache = p->glyphCache();
params.m_logText = strings::MakeUniString("Simplicity is the ultimate sophistication");
yg::StraightTextElement ste(params);
@ -778,7 +745,7 @@ namespace
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
p->drawPath(&m_path[0], m_path.size(), 0, p->skin()->mapPenInfo(m_penInfo), 1);
yg::FontDesc fontDesc(false, 30);
yg::FontDesc fontDesc(30);
p->drawPathText(fontDesc, &m_path[0], m_path.size(), m_text, calc_length(m_path), 0.0, yg::EPosLeft, 0);
}
@ -825,7 +792,7 @@ namespace
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
p->drawPath(&m_testPoints[0], m_testPoints.size(), 0, p->skin()->mapPenInfo(yg::PenInfo(yg::Color(255, 255, 255, 255), 2, 0, 0, 0)), 0);
yg::FontDesc fontDesc(false, 20, yg::Color(0, 0, 0, 255), false);
yg::FontDesc fontDesc(20, yg::Color(0, 0, 0, 255), false);
//m_text = "Simplicity is the ultimate sophistication. Leonardo Da Vinci.";
m_text = "Vinci";
p->drawPathText(fontDesc, &m_testPoints[0], m_testPoints.size(), m_text.c_str(), calc_length(m_testPoints), m_pathOffset, yg::EPosLeft, 1);
@ -854,7 +821,7 @@ namespace
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
p->drawPath(&m_path[0], m_path.size(), 0, p->skin()->mapPenInfo(m_penInfo), 0);
yg::FontDesc fontDesc(false, 20);
yg::FontDesc fontDesc(20);
p->drawPathText(fontDesc, &m_path[0], m_path.size(), m_text, calc_length(m_path), 0.0, yg::EPosCenter, 0);
}
};
@ -874,12 +841,11 @@ namespace
void DoDraw(shared_ptr<yg::gl::Screen> p)
{
yg::StraightTextElement::Params params;
params.m_fontDesc = yg::FontDesc(false, 20);
params.m_fontDesc = yg::FontDesc(20);
params.m_logText = strings::MakeUniString("Simplicity is the ultimate sophistication. Leonardo Da Vinci.");
params.m_depth = 10;
params.m_log2vis = false;
params.m_rm = p->resourceManager().get();
params.m_skin = p->skin().get();
params.m_glyphCache = p->glyphCache();
params.m_pivot = m_path[0];
params.m_position = yg::EPosRight;
@ -918,12 +884,11 @@ namespace
params.m_ptsCount = m_path.size();
params.m_fullLength = calc_length(m_path);
params.m_pathOffset = 0;
params.m_fontDesc = yg::FontDesc(false, 20);
params.m_fontDesc = yg::FontDesc(20);
params.m_logText = strings::MakeUniString("Simplicity is the ultimate sophistication. Leonardo Da Vinci.");
params.m_depth = 10;
params.m_log2vis = false;
params.m_rm = p->resourceManager().get();
params.m_skin = p->skin().get();
params.m_glyphCache = p->glyphCache();
params.m_pivot = m_path[0];
params.m_position = yg::EPosCenter;
@ -961,7 +926,7 @@ namespace
{
p->drawPath(&m_path[0], m_path.size(), 0, p->skin()->mapPenInfo(m_penInfo), 0);
// yg::FontDesc fontDesc(false, 10);
yg::FontDesc fontDesc(false, 20);
yg::FontDesc fontDesc(20);
p->drawPathText(fontDesc, &m_path[0], m_path.size(), m_text, calc_length(m_path), 0.0, yg::EPosCenter, 0);
}
};
@ -990,7 +955,7 @@ namespace
p->drawPath(&m_pathUnder[0], m_pathUnder.size(), 0, p->skin()->mapPenInfo(m_penInfo), 0);
double const len = calc_length(m_path);
yg::FontDesc fontDesc(false, 20);
yg::FontDesc fontDesc(20);
p->drawPathText(fontDesc, &m_pathAbove[0], m_pathAbove.size(), m_text, len, 0.0, yg::EPosAbove, 0);
p->drawPathText(fontDesc, &m_pathUnder[0], m_pathUnder.size(), m_text, len, 0.0, yg::EPosUnder, 0);
@ -1007,7 +972,7 @@ namespace
int startY = 30;
for (size_t i = 0; i < sizesCount; ++i)
{
yg::FontDesc fontDesc(false, startSize + i);
yg::FontDesc fontDesc(startSize + i);
p->drawText(fontDesc, m2::PointD(10, startY), yg::EPosAboveRight, 0, "Simplicity is the ultimate sophistication. Leonardo Da Vinci", 0, true);
startY += fontDesc.m_size;
}
@ -1024,7 +989,7 @@ namespace
int startY = 30;
for (size_t i = 0; i < sizesCount; ++i)
{
yg::FontDesc fontDesc(false, startSize);
yg::FontDesc fontDesc(startSize);
p->drawText(fontDesc, m2::PointD(10, startY), yg::EPosAboveRight, 0, "Simplicity is the ultimate sophistication. Leonardo Da Vinci", 100, true);
p->drawText(fontDesc, m2::PointD(5, startY + (startSize + i) / 2), yg::EPosAboveRight, 0, "This text should be filtered", 100, true);
startY += startSize + i;
@ -1045,8 +1010,7 @@ namespace
for (int i = 0; i < textsCount; ++i)
{
yg::FontDesc fontDesc(false,
rand() % (endSize - startSize) + startSize,
yg::FontDesc fontDesc(rand() % (endSize - startSize) + startSize,
yg::Color(rand() % 255, rand() % 255, rand() % 255, 255)
);
p->drawText(