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

renamed SkinPage into ResourceCache.

Browse source
This commit is contained in:
rachytski 2012-12-04 18:45:45 +03:00 • committed by Alex Zolotarev
parent 79670bcd5a
commit 24dd26625c
18 changed files with 144 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
graphics/area_renderer.cpp
View file

@ -1,7 +1,7 @@
#include "area_renderer.hpp"
#include "resource_style.hpp"
#include "skin.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "opengl/base_texture.hpp"

38
graphics/geometry_batcher.cpp
View file

@ -2,7 +2,7 @@
#include "skin.hpp"
#include "color.hpp"
#include "resource_manager.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "resource_style.hpp"
#include "opengl/base_texture.hpp"
@ -45,7 +45,7 @@ namespace graphics
{
discardPipeline(i);
freePipeline(i);
if (m_skin->page(i)->type() != SkinPage::EStatic)
if (m_skin->page(i)->type() != ResourceCache::EStatic)
freeTexture(i);
}
}
@ -72,13 +72,13 @@ namespace graphics
{
switch (m_type)
{
case SkinPage::EPrimary:
case ResourceCache::EPrimary:
m_storage = resourceManager->primaryStorages()->Reserve();
break;
case SkinPage::EFonts:
case ResourceCache::EFonts:
m_storage = resourceManager->smallStorages()->Reserve();
break;
case SkinPage::EStatic:
case ResourceCache::EStatic:
m_storage = resourceManager->smallStorages()->Reserve();
break;
default:
@ -126,13 +126,13 @@ namespace graphics
else
switch (pipeline.m_type)
{
case SkinPage::EPrimary:
case ResourceCache::EPrimary:
storagePool = resourceManager()->primaryStorages();
break;
case SkinPage::EFonts:
case ResourceCache::EFonts:
storagePool = resourceManager()->smallStorages();
break;
case SkinPage::EStatic:
case ResourceCache::EStatic:
storagePool = resourceManager()->smallStorages();
break;
default:
@ -155,8 +155,8 @@ namespace graphics
/// settings proper skin page type according to useGuiResources flag
if (m_useGuiResources)
for (size_t i = 0; i < m_skin->pagesCount(); ++i)
if (m_skin->page(i)->type() != SkinPage::EStatic)
m_skin->page(i)->setType(SkinPage::ELightWeight);
if (m_skin->page(i)->type() != ResourceCache::EStatic)
m_skin->page(i)->setType(ResourceCache::ELightWeight);
m_pipelines.resize(m_skin->pagesCount());
@ -312,16 +312,16 @@ namespace graphics
switch (m_skin->page(pipelineID)->type())
{
case SkinPage::EPrimary:
case ResourceCache::EPrimary:
texturePool = resourceManager()->primaryTextures();
break;
case SkinPage::EFonts:
case ResourceCache::EFonts:
texturePool = resourceManager()->fontTextures();
break;
case SkinPage::ELightWeight:
case ResourceCache::ELightWeight:
texturePool = resourceManager()->guiThreadTextures();
break;
case SkinPage::EStatic:
case ResourceCache::EStatic:
LOG(LWARNING, ("texture with EStatic can't be freed."));
return;
}
@ -345,21 +345,21 @@ namespace graphics
base_t::discardStorage(pipeline.m_storage);
}
bool GeometryBatcher::flushPipeline(shared_ptr<SkinPage> const & skinPage,
bool GeometryBatcher::flushPipeline(shared_ptr<ResourceCache> const & resourceCache,
int pipelineID)
{
GeometryPipeline & pipeline = m_pipelines[pipelineID];
if (pipeline.m_currentIndex)
{
if (skinPage->hasData())
if (resourceCache->hasData())
{
uploadStyles(&skinPage->uploadQueue()[0], skinPage->uploadQueue().size(), skinPage->texture());
skinPage->clearUploadQueue();
uploadStyles(&resourceCache->uploadQueue()[0], resourceCache->uploadQueue().size(), resourceCache->texture());
resourceCache->clearUploadQueue();
}
unlockPipeline(pipelineID);
drawGeometry(skinPage->texture(),
drawGeometry(resourceCache->texture(),
pipeline.m_storage,
pipeline.m_currentIndex,
0,

6
graphics/geometry_batcher.hpp
View file

@ -7,7 +7,7 @@
#include "opengl/storage.hpp"
#include "display_list_renderer.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "resource_manager.hpp"
#include "../std/vector.hpp"
@ -61,7 +61,7 @@ namespace graphics
/// @}
bool m_useGuiResources;
SkinPage::EType m_type;
ResourceCache::EType m_type;
int verticesLeft();
int indicesLeft();
@ -108,7 +108,7 @@ namespace graphics
void beginFrame();
void endFrame();
bool flushPipeline(shared_ptr<SkinPage> const & skinPage, int pipelineID);
bool flushPipeline(shared_ptr<ResourceCache> const & resourceCache, int pipelineID);
void unlockPipeline(int pipelineID);
void discardPipeline(int pipelineID);

4
graphics/graphics.pro
View file

@ -36,7 +36,7 @@ SOURCES += \
resource_style.cpp \
color.cpp \
skin_loader.cpp \
skin_page.cpp \
resource_cache.cpp \
glyph_cache.cpp \
glyph_cache_impl.cpp \
ft2_debug.cpp \
@ -100,7 +100,7 @@ HEADERS += \
pen_info.hpp \
resource_style.hpp \
color.hpp \
skin_page.hpp \
resource_cache.hpp \
render_target.hpp \
glyph_cache.hpp \
data_formats.hpp \

4
graphics/graphics_tests/screengl_test.cpp
View file

@ -123,7 +123,7 @@ namespace
};
struct TestDrawPathWithSkinPageMiss : public TestDrawPathBase
struct TestDrawPathWithResourceCacheMiss : public TestDrawPathBase
{
typedef TestDrawPathBase base_t;
@ -1379,7 +1379,7 @@ namespace
// UNIT_TEST_GL(TestDrawSGIConvex);
UNIT_TEST_GL(TestDrawPoly);
UNIT_TEST_GL(TestDrawSolidRect);
UNIT_TEST_GL(TestDrawPathWithSkinPageMiss);
UNIT_TEST_GL(TestDrawPathWithResourceCacheMiss);
UNIT_TEST_GL(TestDrawPathWithOffset);
UNIT_TEST_GL(TestDrawPathJoin);
UNIT_TEST_GL(TestDrawPathSolid1PX);

2
graphics/opengl/geometry_renderer.hpp
View file

@ -1,7 +1,7 @@
#pragma once
#include "../defines.hpp"
#include "../skin_page.hpp"
#include "../resource_cache.hpp"
#include "clipper.hpp"

2
graphics/path_renderer.cpp
View file

@ -1,7 +1,7 @@
#include "path_renderer.hpp"
#include "resource_style.hpp"
#include "skin.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "opengl/base_texture.hpp"

92
graphics/skin_page.cpp → graphics/resource_cache.cpp
View file

@ -1,4 +1,4 @@
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "opengl/texture.hpp"
#include "opengl/data_traits.hpp"
@ -15,12 +15,12 @@ namespace graphics
{
typedef gl::Texture<DATA_TRAITS, true> TDynamicTexture;
SkinPage::SkinPage()
ResourceCache::ResourceCache()
: m_type(EStatic),
m_pipelineID(0)
{}
SkinPage::SkinPage(shared_ptr<ResourceManager> const & resourceManager,
ResourceCache::ResourceCache(shared_ptr<ResourceManager> const & resourceManager,
char const * name,
uint8_t pipelineID)
: m_texture(resourceManager->getTexture(name)),
@ -30,7 +30,7 @@ namespace graphics
{
}
SkinPage::SkinPage(shared_ptr<ResourceManager> const & resourceManager,
ResourceCache::ResourceCache(shared_ptr<ResourceManager> const & resourceManager,
EType type,
uint8_t pipelineID)
: m_resourceManager(resourceManager),
@ -40,10 +40,10 @@ namespace graphics
createPacker();
/// clear handles will be called only upon handles overflow,
/// as the texture overflow is processed separately
m_packer.addOverflowFn(bind(&SkinPage::clearHandles, this), 0);
m_packer.addOverflowFn(bind(&ResourceCache::clearHandles, this), 0);
}
void SkinPage::clearHandles()
void ResourceCache::clearHandles()
{
clearPenInfoHandles();
clearColorHandles();
@ -54,18 +54,18 @@ namespace graphics
m_packer.reset();
}
void SkinPage::clearUploadQueue()
void ResourceCache::clearUploadQueue()
{
m_uploadQueue.clear();
}
void SkinPage::clear()
void ResourceCache::clear()
{
clearHandles();
clearUploadQueue();
}
void SkinPage::clearColorHandles()
void ResourceCache::clearColorHandles()
{
for (TColorMap::const_iterator it = m_colorMap.begin(); it != m_colorMap.end(); ++it)
m_styles.erase(it->second);
@ -73,7 +73,7 @@ namespace graphics
m_colorMap.clear();
}
void SkinPage::clearPenInfoHandles()
void ResourceCache::clearPenInfoHandles()
{
for (TPenInfoMap::const_iterator it = m_penInfoMap.begin(); it != m_penInfoMap.end(); ++it)
m_styles.erase(it->second);
@ -81,7 +81,7 @@ namespace graphics
m_penInfoMap.clear();
}
void SkinPage::clearCircleInfoHandles()
void ResourceCache::clearCircleInfoHandles()
{
for (TCircleInfoMap::const_iterator it = m_circleInfoMap.begin(); it != m_circleInfoMap.end(); ++it)
m_styles.erase(it->second);
@ -89,7 +89,7 @@ namespace graphics
m_circleInfoMap.clear();
}
void SkinPage::clearFontHandles()
void ResourceCache::clearFontHandles()
{
for (TGlyphMap::const_iterator it = m_glyphMap.begin(); it != m_glyphMap.end(); ++it)
m_styles.erase(it->second);
@ -97,7 +97,7 @@ namespace graphics
m_glyphMap.clear();
}
void SkinPage::clearImageInfoHandles()
void ResourceCache::clearImageInfoHandles()
{
for (TImageInfoMap::const_iterator it = m_imageInfoMap.begin();
it != m_imageInfoMap.end();
@ -107,7 +107,7 @@ namespace graphics
m_imageInfoMap.clear();
}
uint32_t SkinPage::findImageInfo(ImageInfo const & ii) const
uint32_t ResourceCache::findImageInfo(ImageInfo const & ii) const
{
TImageInfoMap::const_iterator it = m_imageInfoMap.find(ii);
if (it == m_imageInfoMap.end())
@ -116,7 +116,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::mapImageInfo(ImageInfo const & ii)
uint32_t ResourceCache::mapImageInfo(ImageInfo const & ii)
{
uint32_t foundHandle = findImageInfo(ii);
if (foundHandle != m_packer.invalidHandle())
@ -135,12 +135,12 @@ namespace graphics
return h;
}
bool SkinPage::hasRoom(ImageInfo const & ii) const
bool ResourceCache::hasRoom(ImageInfo const & ii) const
{
return m_packer.hasRoom(ii.width() + 4, ii.height() + 4);
}
uint32_t SkinPage::findColor(graphics::Color const & c) const
uint32_t ResourceCache::findColor(graphics::Color const & c) const
{
TColorMap::const_iterator it = m_colorMap.find(c);
if (it == m_colorMap.end())
@ -149,7 +149,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::mapColor(graphics::Color const & c)
uint32_t ResourceCache::mapColor(graphics::Color const & c)
{
uint32_t foundHandle = findColor(c);
@ -169,12 +169,12 @@ namespace graphics
return h;
}
bool SkinPage::hasRoom(Color const & ) const
bool ResourceCache::hasRoom(Color const & ) const
{
return m_packer.hasRoom(2, 2);
}
uint32_t SkinPage::findSymbol(char const * symbolName) const
uint32_t ResourceCache::findSymbol(char const * symbolName) const
{
TPointNameMap::const_iterator it = m_pointNameMap.find(symbolName);
if (it == m_pointNameMap.end())
@ -183,7 +183,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::findGlyph(GlyphKey const & g) const
uint32_t ResourceCache::findGlyph(GlyphKey const & g) const
{
TGlyphMap::const_iterator it = m_glyphMap.find(g);
if (it == m_glyphMap.end())
@ -192,7 +192,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::mapGlyph(graphics::GlyphKey const & g, graphics::GlyphCache * glyphCache)
uint32_t ResourceCache::mapGlyph(graphics::GlyphKey const & g, graphics::GlyphCache * glyphCache)
{
uint32_t foundHandle = findGlyph(g);
if (foundHandle != m_packer.invalidHandle())
@ -217,18 +217,18 @@ namespace graphics
return m_glyphMap[g];
}
bool SkinPage::hasRoom(GlyphKey const & gk, GlyphCache * glyphCache) const
bool ResourceCache::hasRoom(GlyphKey const & gk, GlyphCache * glyphCache) const
{
shared_ptr<GlyphInfo> gi = glyphCache->getGlyphInfo(gk);
return m_packer.hasRoom(gi->m_metrics.m_width + 4, gi->m_metrics.m_height + 4);
}
bool SkinPage::hasRoom(m2::PointU const * sizes, size_t cnt) const
bool ResourceCache::hasRoom(m2::PointU const * sizes, size_t cnt) const
{
return m_packer.hasRoom(sizes, cnt);
}
uint32_t SkinPage::findCircleInfo(CircleInfo const & circleInfo) const
uint32_t ResourceCache::findCircleInfo(CircleInfo const & circleInfo) const
{
TCircleInfoMap::const_iterator it = m_circleInfoMap.find(circleInfo);
if (it == m_circleInfoMap.end())
@ -237,7 +237,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::mapCircleInfo(CircleInfo const & circleInfo)
uint32_t ResourceCache::mapCircleInfo(CircleInfo const & circleInfo)
{
uint32_t foundHandle = findCircleInfo(circleInfo);
@ -259,13 +259,13 @@ namespace graphics
return m_circleInfoMap[circleInfo];
}
bool SkinPage::hasRoom(CircleInfo const & circleInfo) const
bool ResourceCache::hasRoom(CircleInfo const & circleInfo) const
{
m2::PointU sz = circleInfo.patternSize();
return m_packer.hasRoom(sz.x, sz.y);
}
uint32_t SkinPage::findPenInfo(PenInfo const & penInfo) const
uint32_t ResourceCache::findPenInfo(PenInfo const & penInfo) const
{
TPenInfoMap::const_iterator it = m_penInfoMap.find(penInfo);
if (it == m_penInfoMap.end())
@ -274,7 +274,7 @@ namespace graphics
return it->second;
}
uint32_t SkinPage::mapPenInfo(PenInfo const & penInfo)
uint32_t ResourceCache::mapPenInfo(PenInfo const & penInfo)
{
uint32_t foundHandle = findPenInfo(penInfo);
@ -301,49 +301,49 @@ namespace graphics
return m_penInfoMap[penInfo];
}
bool SkinPage::hasRoom(const PenInfo &penInfo) const
bool ResourceCache::hasRoom(const PenInfo &penInfo) const
{
m2::PointU p = penInfo.patternSize();
return m_packer.hasRoom(p.x, p.y);
}
void SkinPage::setType(SkinPage::EType type)
void ResourceCache::setType(ResourceCache::EType type)
{
m_type = type;
createPacker();
if (m_type != EStatic)
m_packer.addOverflowFn(bind(&SkinPage::clearHandles, this), 0);
m_packer.addOverflowFn(bind(&ResourceCache::clearHandles, this), 0);
}
SkinPage::EType SkinPage::type() const
ResourceCache::EType ResourceCache::type() const
{
return m_type;
}
bool SkinPage::hasData()
bool ResourceCache::hasData()
{
return !m_uploadQueue.empty();
}
SkinPage::TUploadQueue const & SkinPage::uploadQueue() const
ResourceCache::TUploadQueue const & ResourceCache::uploadQueue() const
{
return m_uploadQueue;
}
void SkinPage::checkTexture() const
void ResourceCache::checkTexture() const
{
if ((m_type != EStatic) && (m_texture == 0))
reserveTexture();
}
void SkinPage::setPipelineID(uint8_t pipelineID)
void ResourceCache::setPipelineID(uint8_t pipelineID)
{
m_pipelineID = pipelineID;
for (TStyles::iterator it = m_styles.begin(); it != m_styles.end(); ++it)
it->second->m_pipelineID = pipelineID;
}
ResourceStyle * SkinPage::fromID(uint32_t idx) const
ResourceStyle * ResourceCache::fromID(uint32_t idx) const
{
TStyles::const_iterator it = m_styles.find(idx);
@ -353,23 +353,23 @@ namespace graphics
return it->second.get();
}
void SkinPage::addOverflowFn(overflowFn fn, int priority)
void ResourceCache::addOverflowFn(overflowFn fn, int priority)
{
m_packer.addOverflowFn(fn, priority);
}
shared_ptr<gl::BaseTexture> const & SkinPage::texture() const
shared_ptr<gl::BaseTexture> const & ResourceCache::texture() const
{
checkTexture();
return m_texture;
}
bool SkinPage::hasTexture() const
bool ResourceCache::hasTexture() const
{
return m_texture != 0;
}
void SkinPage::setTexture(shared_ptr<gl::BaseTexture> const & texture)
void ResourceCache::setTexture(shared_ptr<gl::BaseTexture> const & texture)
{
m_texture = texture;
m_packer = m2::Packer(texture->width(),
@ -377,12 +377,12 @@ namespace graphics
0x00FFFFFF - 1);
}
void SkinPage::resetTexture()
void ResourceCache::resetTexture()
{
m_texture.reset();
}
void SkinPage::reserveTexture() const
void ResourceCache::reserveTexture() const
{
switch (m_type)
{
@ -400,7 +400,7 @@ namespace graphics
}
}
void SkinPage::createPacker()
void ResourceCache::createPacker()
{
switch (m_type)
{
@ -424,7 +424,7 @@ namespace graphics
}
}
shared_ptr<ResourceManager> const & SkinPage::resourceManager() const
shared_ptr<ResourceManager> const & ResourceCache::resourceManager() const
{
return m_resourceManager;
}

12
graphics/skin_page.hpp → graphics/resource_cache.hpp
View file

@ -24,7 +24,7 @@ namespace graphics
class ResourceManager;
struct GlyphInfo;
class SkinPage
class ResourceCache
{
public:
@ -102,17 +102,17 @@ namespace graphics
void setPipelineID(uint8_t pipelineID);
/// creation of detached page
SkinPage();
ResourceCache();
/// creation of a static page
SkinPage(shared_ptr<ResourceManager> const & resourceManager,
ResourceCache(shared_ptr<ResourceManager> const & resourceManager,
char const * name,
uint8_t pipelineID);
/// creation of a dynamic page
SkinPage(shared_ptr<ResourceManager> const & resourceManager,
EType type,
uint8_t pipelineID);
ResourceCache(shared_ptr<ResourceManager> const & resourceManager,
EType type,
uint8_t pipelineID);
void reserveTexture() const;
void resetTexture();

2
graphics/shape_renderer.cpp
View file

@ -2,7 +2,7 @@
#include "skin.hpp"
#include "pen_info.hpp"
#include "resource_style.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "opengl/base_texture.hpp"

96
graphics/skin.cpp
View file

@ -1,5 +1,5 @@
#include "skin.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "resource_style.hpp"
#include "resource_manager.hpp"
@ -14,44 +14,44 @@
namespace graphics
{
Skin::Skin(shared_ptr<ResourceManager> const & resourceManager,
Skin::TSkinPages const & pages)
: m_pages(pages),
m_staticPagesCount(pages.size()),
Skin::TResourceCaches const & caches)
: m_caches(caches),
m_staticPagesCount(caches.size()),
m_resourceManager(resourceManager)
{
m_textPage = m_pages.size();
m_textPage = m_caches.size();
addTextPages(1);
m_startDynamicPage = m_dynamicPage = m_pages.size();
m_startDynamicPage = m_dynamicPage = m_caches.size();
m_dynamicPagesCount = 2;
addDynamicPages(m_dynamicPagesCount);
}
void Skin::addTextPages(int count)
{
m_pages.reserve(m_pages.size() + count);
m_caches.reserve(m_caches.size() + count);
addClearPageFn(bind(&Skin::clearPageHandles, this, _1), 0);
for (int i = 0; i < count; ++i)
{
uint8_t pipelineID = (uint8_t)m_pages.size();
m_pages.push_back(make_shared_ptr(new SkinPage(m_resourceManager, SkinPage::EFonts, pipelineID)));
m_pages.back()->addOverflowFn(bind(&Skin::onTextOverflow, this, pipelineID), 0);
uint8_t pipelineID = (uint8_t)m_caches.size();
m_caches.push_back(make_shared_ptr(new ResourceCache(m_resourceManager, ResourceCache::EFonts, pipelineID)));
m_caches.back()->addOverflowFn(bind(&Skin::onTextOverflow, this, pipelineID), 0);
}
}
void Skin::addDynamicPages(int count)
{
m_pages.reserve(m_pages.size() + count);
m_caches.reserve(m_caches.size() + count);
addClearPageFn(bind(&Skin::clearPageHandles, this, _1), 0);
for (int i = 0; i < count; ++i)
{
uint8_t pipelineID = (uint8_t)m_pages.size();
m_pages.push_back(make_shared_ptr(new SkinPage(m_resourceManager, SkinPage::EPrimary, pipelineID)));
m_pages.back()->addOverflowFn(bind(&Skin::onDynamicOverflow, this, pipelineID), 0);
uint8_t pipelineID = (uint8_t)m_caches.size();
m_caches.push_back(make_shared_ptr(new ResourceCache(m_resourceManager, ResourceCache::EPrimary, pipelineID)));
m_caches.back()->addOverflowFn(bind(&Skin::onDynamicOverflow, this, pipelineID), 0);
}
}
@ -79,15 +79,15 @@ namespace graphics
id_pair_t p = unpackID(id);
ASSERT(p.first < m_pages.size(), ());
return m_pages[p.first]->fromID(p.second);
ASSERT(p.first < m_caches.size(), ());
return m_caches[p.first]->fromID(p.second);
}
uint32_t Skin::mapSymbol(char const * symbolName)
{
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
uint32_t res = m_pages[i]->findSymbol(symbolName);
uint32_t res = m_caches[i]->findSymbol(symbolName);
if (res != invalidPageHandle())
return packID(i, res);
}
@ -99,68 +99,68 @@ namespace graphics
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
res = m_pages[i]->findColor(c);
res = m_caches[i]->findColor(c);
if (res != invalidPageHandle())
return packID(i, res);
}
if (!m_pages[m_dynamicPage]->hasRoom(c))
if (!m_caches[m_dynamicPage]->hasRoom(c))
flushDynamicPage();
return packID(m_dynamicPage, m_pages[m_dynamicPage]->mapColor(c));
return packID(m_dynamicPage, m_caches[m_dynamicPage]->mapColor(c));
}
uint32_t Skin::mapPenInfo(PenInfo const & penInfo)
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
res = m_pages[i]->findPenInfo(penInfo);
res = m_caches[i]->findPenInfo(penInfo);
if (res != invalidPageHandle())
return packID(i, res);
}
if (!m_pages[m_dynamicPage]->hasRoom(penInfo))
if (!m_caches[m_dynamicPage]->hasRoom(penInfo))
flushDynamicPage();
return packID(m_dynamicPage, m_pages[m_dynamicPage]->mapPenInfo(penInfo));
return packID(m_dynamicPage, m_caches[m_dynamicPage]->mapPenInfo(penInfo));
}
uint32_t Skin::mapCircleInfo(CircleInfo const & circleInfo)
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
res = m_pages[i]->findCircleInfo(circleInfo);
res = m_caches[i]->findCircleInfo(circleInfo);
if (res != invalidPageHandle())
return packID(i, res);
}
if (!m_pages[m_dynamicPage]->hasRoom(circleInfo))
if (!m_caches[m_dynamicPage]->hasRoom(circleInfo))
flushDynamicPage();
return packID(m_dynamicPage, m_pages[m_dynamicPage]->mapCircleInfo(circleInfo));
return packID(m_dynamicPage, m_caches[m_dynamicPage]->mapCircleInfo(circleInfo));
}
uint32_t Skin::mapImageInfo(ImageInfo const & imageInfo)
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
res = m_pages[i]->findImageInfo(imageInfo);
res = m_caches[i]->findImageInfo(imageInfo);
if (res != invalidPageHandle())
return packID(i, res);
}
if (!m_pages[m_dynamicPage]->hasRoom(imageInfo))
if (!m_caches[m_dynamicPage]->hasRoom(imageInfo))
flushDynamicPage();
return packID(m_dynamicPage, m_pages[m_dynamicPage]->mapImageInfo(imageInfo));
return packID(m_dynamicPage, m_caches[m_dynamicPage]->mapImageInfo(imageInfo));
}
bool Skin::mapPenInfo(PenInfo const * penInfos, uint32_t * styleIDS, size_t count)
@ -172,12 +172,12 @@ namespace graphics
do
{
styleIDS[i] = m_pages[m_dynamicPage]->findPenInfo(penInfos[i]);
styleIDS[i] = m_caches[m_dynamicPage]->findPenInfo(penInfos[i]);
if ((styleIDS[i] == invalidPageHandle()) || (unpackID(styleIDS[i]).first != m_dynamicPage))
{
/// try to pack on the currentDynamicPage
while (!m_pages[m_dynamicPage]->hasRoom(penInfos[i]))
while (!m_caches[m_dynamicPage]->hasRoom(penInfos[i]))
{
/// no room - flush the page
flushDynamicPage();
@ -196,7 +196,7 @@ namespace graphics
i = 0;
}
styleIDS[i] = packID(m_dynamicPage, m_pages[m_dynamicPage]->mapPenInfo(penInfos[i]));
styleIDS[i] = packID(m_dynamicPage, m_caches[m_dynamicPage]->mapPenInfo(penInfos[i]));
}
++i;
@ -210,28 +210,28 @@ namespace graphics
{
uint32_t res = invalidPageHandle();
for (uint8_t i = 0; i < m_pages.size(); ++i)
for (uint8_t i = 0; i < m_caches.size(); ++i)
{
res = m_pages[i]->findGlyph(gk);
res = m_caches[i]->findGlyph(gk);
if (res != invalidPageHandle())
return packID(i, res);
}
if (!m_pages[m_textPage]->hasRoom(gk, glyphCache))
if (!m_caches[m_textPage]->hasRoom(gk, glyphCache))
flushTextPage();
return packID(m_textPage, m_pages[m_textPage]->mapGlyph(gk, glyphCache));
return packID(m_textPage, m_caches[m_textPage]->mapGlyph(gk, glyphCache));
}
shared_ptr<SkinPage> const & Skin::page(int i) const
shared_ptr<ResourceCache> const & Skin::page(int i) const
{
ASSERT(i < m_pages.size(), ());
return m_pages[i];
ASSERT(i < m_caches.size(), ());
return m_caches[i];
}
size_t Skin::pagesCount() const
{
return m_pages.size();
return m_caches.size();
}
void Skin::addClearPageFn(clearPageFn fn, int priority)
@ -306,7 +306,7 @@ namespace graphics
int Skin::nextPage(int i) const
{
ASSERT(i < m_pages.size(), ());
ASSERT(i < m_caches.size(), ());
if (isDynamicPage(i))
return nextDynamicPage();
@ -355,7 +355,7 @@ namespace graphics
void Skin::clearHandles()
{
for (unsigned i = 0; i < m_pages.size(); ++i)
m_pages[i]->clear();
for (unsigned i = 0; i < m_caches.size(); ++i)
m_caches[i]->clear();
}
}

10
graphics/skin.hpp
View file

@ -23,7 +23,7 @@ namespace graphics
class BaseTexture;
}
class SkinPage;
class ResourceCache;
class ResourceManager;
struct ResourceStyle;
struct PenInfo;
@ -37,13 +37,13 @@ namespace graphics
{
public:
typedef vector<shared_ptr<SkinPage> > TSkinPages;
typedef vector<shared_ptr<ResourceCache> > TResourceCaches;
typedef function<void(uint8_t)> clearPageFn;
typedef function<void(uint8_t)> overflowFn;
private:
TSkinPages m_pages;
TResourceCaches m_caches;
uint8_t m_startDynamicPage;
uint8_t m_dynamicPage;
@ -57,7 +57,7 @@ namespace graphics
shared_ptr<ResourceManager> m_resourceManager;
Skin(shared_ptr<ResourceManager> const & resourceManager,
TSkinPages const & pages);
TResourceCaches const & pages);
friend class SkinLoader;
@ -135,7 +135,7 @@ namespace graphics
/// is getting cleared.
void addClearPageFn(clearPageFn fn, int priority);
shared_ptr<SkinPage> const & page(int i) const;
shared_ptr<ResourceCache> const & page(int i) const;
size_t pagesCount() const;

4
graphics/skin_loader.cpp
View file

@ -2,7 +2,7 @@
#include "skin_loader.hpp"
#include "resource_manager.hpp"
#include "resource_style.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "../base/string_utils.hpp"
@ -46,7 +46,7 @@ namespace graphics
void SkinLoader::popPage()
{
m_pages.push_back(make_shared_ptr(new SkinPage(m_resourceManager, m_fileName.c_str(), m_pages.size())));
m_pages.push_back(make_shared_ptr(new ResourceCache(m_resourceManager, m_fileName.c_str(), m_pages.size())));
TStylesList::iterator prevIt = m_stylesList.end();

4
graphics/skin_loader.hpp
View file

@ -37,7 +37,7 @@ namespace graphics
}
class ResourceManager;
class SkinPage;
class ResourceCache;
struct ResourceStyle;
struct GlyphStyle;
@ -79,7 +79,7 @@ namespace graphics
/// skin-specific parameters
vector<shared_ptr<SkinPage> > m_pages;
vector<shared_ptr<ResourceCache> > m_pages;
/// skin-page specific parameters
string m_fileName;

2
graphics/text_element.cpp
View file

@ -1,7 +1,7 @@
#include "text_element.hpp"
#include "screen.hpp"
#include "skin.hpp"
#include "skin_page.hpp"
#include "resource_cache.hpp"
#include "resource_manager.hpp"
#include "overlay_renderer.hpp"
#include "resource_style.hpp"

2
graphics/text_element.hpp
View file

@ -16,7 +16,7 @@ namespace graphics
{
class ResourceManager;
class Skin;
class SkinPage;
class ResourceCache;
class OverlayRenderer;
class TextElement : public OverlayElement

4
map/drawer.cpp
View file

@ -59,7 +59,7 @@ Drawer::Drawer(Params const & params)
m_pScreen->setSkin(m_pSkin);
if (m_pSkin)
m_pSkin->addClearPageFn(bind(&Drawer::ClearSkinPage, ThreadSlot(), _1), 0);
m_pSkin->addClearPageFn(bind(&Drawer::ClearResourceCache, ThreadSlot(), _1), 0);
}
namespace
@ -83,7 +83,7 @@ namespace
};
}
void Drawer::ClearSkinPage(size_t threadSlot, uint8_t pipelineID)
void Drawer::ClearResourceCache(size_t threadSlot, uint8_t pipelineID)
{
drule::rules().ForEachRule(DoMakeInvalidRule(threadSlot, pipelineID));
}

2
map/drawer.hpp
View file

@ -75,7 +75,7 @@ class Drawer
shared_ptr<graphics::Screen> m_pScreen;
shared_ptr<graphics::Skin> m_pSkin;
static void ClearSkinPage(size_t threadSlot, uint8_t pipelineID);
static void ClearResourceCache(size_t threadSlot, uint8_t pipelineID);
typedef pair<size_t, uint32_t> FeatureID;