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

[android] switched to TilingRenderPolicyST by default.

Browse source
This commit is contained in:
rachytski 2011-12-30 01:29:32 +04:00 • committed by Alex Zolotarev
parent f8822fa29a
commit cd07b0c61e
19 changed files with 381 additions and 192 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
map/framework.cpp
View file

@ -313,8 +313,11 @@ void Framework::DrawModel(shared_ptr<PaintEvent> const & e,
}
catch (redraw_operation_cancelled const &)
{
e->drawer()->screen()->renderState()->m_isEmptyModelCurrent = false;
e->drawer()->screen()->renderState()->m_isEmptyModelActual = false;
if (e->drawer()->screen()->renderState())
{
e->drawer()->screen()->renderState()->m_isEmptyModelCurrent = false;
e->drawer()->screen()->renderState()->m_isEmptyModelActual = false;
}
}
if (m_navigator.Update(m_timer.ElapsedSeconds()))

4
map/map.pro
View file

@ -43,7 +43,8 @@ HEADERS += \
measurement_utils.hpp \
partial_render_policy.hpp \
proto_to_yg_styles.hpp \
test_render_policy.hpp
test_render_policy.hpp \
queued_render_policy.hpp
SOURCES += \
feature_vec_model.cpp \
@ -85,3 +86,4 @@ SOURCES += \
}

33
map/partial_render_policy.cpp
View file

@ -194,17 +194,33 @@ void PartialRenderPolicy::ProcessRenderQueue(list<yg::gl::Renderer::Packet> & re
else
{
if (renderQueue.empty())
{
m_hasPacket = false;
m_glCondition.Signal();
}
else
{
m_hasPacket = true;
while ((maxPackets != 0) && (!renderQueue.empty()))
/// searching for "frame boundary" markers (empty packets)
list<yg::gl::Renderer::Packet>::iterator first = renderQueue.begin();
list<yg::gl::Renderer::Packet>::iterator last = renderQueue.begin();
int packetsLeft = maxPackets;
while ((packetsLeft != 0) && (last != renderQueue.end()))
{
m_frameGLQueue.push_back(renderQueue.front());
renderQueue.pop_front();
yg::gl::Renderer::Packet p = *last;
if ((p.m_command == 0) && (p.m_state == 0))
{
LOG(LINFO, ("found frame boundary"));
/// found frame boundary, copying
copy(first, last++, back_inserter(m_frameGLQueue));
/// erasing from the main queue
renderQueue.erase(first, last);
first = renderQueue.begin();
last = renderQueue.begin();
}
else
++last;
--packetsLeft;
}
}
}
@ -252,7 +268,10 @@ void PartialRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
m_frameGLQueue.clear();
if (m_IsDebugging)
{
LOG(LINFO, ("processed", cmdProcessed, "commands"));
LOG(LINFO, (m_glQueue.Size(), "commands left"));
}
{
threads::ConditionGuard guard(m_glCondition);

2
map/partial_render_policy.hpp
View file

@ -17,9 +17,7 @@ private:
threads::Condition m_glCondition;
yg::gl::Renderer::Packet m_currentPacket;
shared_ptr<yg::gl::Screen::BaseState> m_curState;
bool m_hasPacket;
shared_ptr<yg::gl::Renderer::BaseState> m_state;

16
map/queued_render_policy.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "../base/threaded_list.hpp"
#include "../yg/renderer.hpp"
/*
/// base class for policy using separate queue of gl commands.
class QueuedRenderPolicy : public RenderPolicy
{
private:
ThreadedList<yg::gl::Renderer::Packet> m_glQueue;
public:
ThreadedList<yg::gl::Renderer::Packet> * GetGLQueue() const;
};*/

2
map/render_policy.cpp
View file

@ -157,7 +157,7 @@ RenderPolicy * CreateRenderPolicy(VideoTimer * videoTimer,
else
{
#ifdef OMIM_OS_ANDROID
return new PartialRenderPolicy(videoTimer, useDefaultFB, rmParams, primaryRC);
return new TilingRenderPolicyST(videoTimer, useDefaultFB, rmParams, primaryRC);
#endif
#ifdef OMIM_OS_IPHONE
return new RenderPolicyMT(videoTimer, useDefaultFB, rmParams, primaryRC);

6
map/render_queue_routine.cpp
View file

@ -271,7 +271,8 @@ void RenderQueueRoutine::Do()
/* params.m_isDebugging = true;
params.m_drawPathes = false;
params.m_drawAreas = false;
params.m_drawTexts = false;*/
params.m_drawTexts = false;
params.m_drawSymbols = false;*/
m_threadDrawer = make_shared_ptr(new DrawerYG(params));
@ -538,6 +539,9 @@ void RenderQueueRoutine::invalidate()
command->m_windowHandles = m_windowHandles;
m_glQueue->PushBack(yg::gl::Renderer::Packet(command));
}
if (m_glQueue)
m_glQueue->PushBack(yg::gl::Renderer::Packet());
}
void RenderQueueRoutine::addCommand(render_fn_t const & fn, ScreenBase const & frameScreen)

8
map/screen_coverage.cpp
View file

@ -105,7 +105,7 @@ void ScreenCoverage::Merge(Tiler::RectInfo const & ri)
else
{
m_infoLayer.cache(m_stylesCache);
m_stylesCache->upload();
// m_stylesCache->upload();
}
}
}
@ -198,7 +198,7 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
else
{
m_infoLayer.cache(m_stylesCache);
m_stylesCache->upload();
// m_stylesCache->upload();
}
/// clearing all old commands
@ -251,10 +251,10 @@ void ScreenCoverage::Draw(yg::gl::Screen * s, ScreenBase const & screen)
s->blit(&infos[0], infos.size(), true);
if (m_stylesCache)
/* if (m_stylesCache)
s->setAdditionalSkinPage(m_stylesCache->cachePage());
m_infoLayer.draw(s, m_screen.PtoGMatrix() * screen.GtoPMatrix());
m_infoLayer.draw(s, m_screen.PtoGMatrix() * screen.GtoPMatrix());*/
}
void ScreenCoverage::EndFrame(yg::gl::Screen *s)

59
map/test_render_policy.cpp
View file

@ -129,17 +129,6 @@ void TestRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
using namespace yg::gl;
/* OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_auxFrameBuffer->id()));
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_backBuffer->id(), 0));
utils::setupCoordinates(512, 512, false);
make_shared_ptr(new Renderer::ClearCommand(m_bgColor))->perform();
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_actualTarget->id(), 0));
utils::setupCoordinates(512, 512, false);
make_shared_ptr(new Renderer::ClearCommand(m_bgColor))->perform();*/
OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_frameBuffer->id()));
utils::setupCoordinates(512, 512, false);
@ -160,12 +149,7 @@ void TestRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
/// performing updateActualTarget
swap(m_actualTarget, m_backBuffer);
OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_auxFrameBuffer->id()));
utils::setupCoordinates(512, 512, false);
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_backBuffer->id(), 0));
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_actualTarget->id(), 0));
/* OGLCHECK(glClearColor(m_bgColor.r / 255.0,
m_bgColor.g / 255.0,
@ -177,15 +161,15 @@ void TestRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
shared_ptr<Blitter::IMMDrawTexturedRect> immDrawTexturedRect;
immDrawTexturedRect.reset(
new Blitter::IMMDrawTexturedRect(m2::RectF(0, 0, m_actualTarget->width(), m_actualTarget->height()),
new Blitter::IMMDrawTexturedRect(m2::RectF(0, 0, m_backBuffer->width(), m_backBuffer->height()),
m2::RectF(0, 0, 1, 1),
m_actualTarget,
m_backBuffer,
m_resourceManager));
immDrawTexturedRect->perform();
immDrawTexturedRect.reset();
OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_frameBuffer->id()));
// OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_frameBuffer->id()));
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_backBuffer->id(), 0));
/// drawing with Z-order
@ -196,10 +180,8 @@ void TestRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
/// performing last updateActualTarget
swap(m_actualTarget, m_backBuffer);
OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_auxFrameBuffer->id()));
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_backBuffer->id(), 0));
// OGLCHECK(glBindFramebufferFn(GL_FRAMEBUFFER_MWM, m_auxFrameBuffer->id()));
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_actualTarget->id(), 0));
/* OGLCHECK(glClearColor(m_bgColor.r / 255.0,
m_bgColor.g / 255.0,
@ -209,17 +191,42 @@ void TestRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
OGLCHECK(glClear(GL_COLOR_BUFFER_BIT));*/
immDrawTexturedRect.reset(
new Blitter::IMMDrawTexturedRect(m2::RectF(0, 0, m_actualTarget->width(), m_actualTarget->height()),
new Blitter::IMMDrawTexturedRect(m2::RectF(0, 0, m_backBuffer->width(), m_backBuffer->height()),
m2::RectF(0, 0, 1, 1),
m_actualTarget,
m_backBuffer,
m_resourceManager));
immDrawTexturedRect->perform();
immDrawTexturedRect.reset();
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_backBuffer->id(), 0));
e->drawer()->screen()->drawRectangle(m2::RectD(90, 150, 190, 250), yg::Color(255, 0, 255, 255), 20);
e->drawer()->screen()->drawRectangle(m2::RectD(120, 180, 220, 280), yg::Color(128, 128, 255, 255), 10);
e->drawer()->screen()->flush(-1);
/// performing updateActualTarget
OGLCHECK(glFramebufferTexture2DFn(GL_FRAMEBUFFER_MWM, GL_COLOR_ATTACHMENT0_MWM, GL_TEXTURE_2D, m_actualTarget->id(), 0));
immDrawTexturedRect.reset(
new Blitter::IMMDrawTexturedRect(m2::RectF(0, 0, m_backBuffer->width(), m_backBuffer->height()),
m2::RectF(0, 0, 1, 1),
m_backBuffer,
m_resourceManager));
immDrawTexturedRect->perform();
immDrawTexturedRect.reset();
m_primaryFrameBuffer->makeCurrent();
utils::setupCoordinates(m_primaryFrameBuffer->width(), m_primaryFrameBuffer->height(), true);
e->drawer()->screen()->clear(m_bgColor);
e->drawer()->screen()->blit(m_actualTarget, m_screen, s);
}
m2::RectI const TestRenderPolicy::OnSize(int w, int h)
{
m_primaryFrameBuffer->onSize(w, h);
return RenderPolicy::OnSize(w, h);
}

2
map/test_render_policy.hpp
View file

@ -26,4 +26,6 @@ public:
void DrawFrame(shared_ptr<PaintEvent> const & pe,
ScreenBase const & screenBase);
m2::RectI const OnSize(int w, int h);
};

4
map/tile_renderer.cpp
View file

@ -20,7 +20,8 @@ TileRenderer::TileRenderer(
RenderPolicy::TRenderFn const & renderFn,
shared_ptr<yg::gl::RenderContext> const & primaryRC,
shared_ptr<yg::ResourceManager> const & rm,
double visualScale
double visualScale,
yg::gl::Renderer::PacketsQueue * packetsQueue
) : m_queue(executorsCount),
m_tileCache(maxTilesCount - executorsCount - 1),
m_renderFn(renderFn),
@ -52,6 +53,7 @@ TileRenderer::TileRenderer(
params.m_threadID = i;
params.m_visualScale = visualScale;
params.m_skinName = m_skinName;
params.m_renderQueue = packetsQueue;
/* params.m_isDebugging = true;
params.m_drawPathes = false;
params.m_drawAreas = false;

3
map/tile_renderer.hpp
View file

@ -73,7 +73,8 @@ public:
RenderPolicy::TRenderFn const & renderFn,
shared_ptr<yg::gl::RenderContext> const & primaryRC,
shared_ptr<yg::ResourceManager> const & rm,
double visualScale);
double visualScale,
yg::gl::Renderer::PacketsQueue * packetsQueue);
/// destructor.
virtual ~TileRenderer();
/// add command to the commands queue.

3
map/tiling_render_policy_mt.cpp
View file

@ -170,7 +170,8 @@ void TilingRenderPolicyMT::SetRenderFn(TRenderFn renderFn)
renderFn,
m_primaryRC,
m_resourceManager,
GetPlatform().VisualScale()));
GetPlatform().VisualScale(),
0));
m_coverageGenerator.reset(new CoverageGenerator(GetPlatform().TileSize(),
GetPlatform().ScaleEtalonSize(),

334
map/tiling_render_policy_st.cpp
View file

@ -14,33 +14,47 @@
#include "../platform/platform.hpp"
#include "../base/SRC_FIRST.hpp"
#include "../platform/platform.hpp"
#include "../std/bind.hpp"
#include "../geometry/screenbase.hpp"
#include "../yg/base_texture.hpp"
#include "../yg/internal/opengl.hpp"
#include "drawer_yg.hpp"
#include "events.hpp"
#include "tiling_render_policy_mt.hpp"
#include "window_handle.hpp"
#include "screen_coverage.hpp"
TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
bool useDefaultFB,
yg::ResourceManager::Params const & rmParams,
shared_ptr<yg::gl::RenderContext> const & primaryRC)
: RenderPolicy(primaryRC, true),
m_tileCache(GetPlatform().MaxTilesCount() - 1),
m_tiler(GetPlatform().TileSize(), GetPlatform().ScaleEtalonSize())
: RenderPolicy(primaryRC, true)
{
yg::ResourceManager::Params rmp = rmParams;
rmp.m_primaryStoragesParams = yg::ResourceManager::StoragePoolParams(50000 * sizeof(yg::gl::Vertex),
rmp.m_primaryStoragesParams = yg::ResourceManager::StoragePoolParams(5000 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10000 * sizeof(unsigned short),
sizeof(unsigned short),
15,
false,
4,
true,
1,
false,
2,
"primaryStorage");
rmp.m_smallStoragesParams = yg::ResourceManager::StoragePoolParams(5000 * sizeof(yg::gl::Vertex),
rmp.m_smallStoragesParams = yg::ResourceManager::StoragePoolParams(2000 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10000 * sizeof(unsigned short),
4000 * sizeof(unsigned short),
sizeof(unsigned short),
100,
false,
true,
false,
1,
"smallStorage");
@ -54,9 +68,9 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
1,
"blitStorage");
rmp.m_multiBlitStoragesParams = yg::ResourceManager::StoragePoolParams(500 * sizeof(yg::gl::Vertex),
rmp.m_multiBlitStoragesParams = yg::ResourceManager::StoragePoolParams(1500 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
500 * sizeof(unsigned short),
3000 * sizeof(unsigned short),
sizeof(unsigned short),
10,
true,
@ -65,14 +79,14 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
"multiBlitStorage");
rmp.m_guiThreadStoragesParams = yg::ResourceManager::StoragePoolParams(300 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
600 * sizeof(unsigned short),
sizeof(unsigned short),
20,
true,
true,
1,
"guiThreadStorage");
sizeof(yg::gl::Vertex),
600 * sizeof(unsigned short),
sizeof(unsigned short),
20,
true,
true,
1,
"guiThreadStorage");
rmp.m_primaryTexturesParams = yg::ResourceManager::TexturePoolParams(512,
256,
@ -101,9 +115,19 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
true,
true,
false,
5,
4,
"renderTargetTexture");
rmp.m_styleCacheTexturesParams = yg::ResourceManager::TexturePoolParams(rmp.m_fontTexturesParams.m_texWidth,
rmp.m_fontTexturesParams.m_texHeight,
2,
rmp.m_texFormat,
true,
true,
true,
1,
"styleCacheTexture");
rmp.m_guiThreadTexturesParams = yg::ResourceManager::TexturePoolParams(256,
128,
4,
@ -121,10 +145,13 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
GetPlatform().CpuCores() + 2,
GetPlatform().CpuCores());
rmp.m_useSingleThreadedOGL = false;
rmp.m_useSingleThreadedOGL = true;
rmp.m_useVA = !yg::gl::g_isBufferObjectsSupported;
rmp.fitIntoLimits();
m_maxTilesCount = rmp.m_renderTargetTexturesParams.m_texCount;
m_resourceManager.reset(new yg::ResourceManager(rmp));
Platform::FilesList fonts;
@ -140,8 +167,8 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID();
p.m_skinName = GetPlatform().SkinName();
p.m_visualScale = GetPlatform().VisualScale();
p.m_isSynchronized = true;
p.m_useGuiResources = true;
p.m_isSynchronized = false;
m_drawer.reset(new DrawerYG(p));
@ -150,132 +177,187 @@ TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer,
m_windowHandle->setUpdatesEnabled(false);
m_windowHandle->setVideoTimer(videoTimer);
m_windowHandle->setRenderContext(primaryRC);
}
/// render single tile on the same thread
shared_ptr<yg::gl::FrameBuffer> frameBuffer(new yg::gl::FrameBuffer());
void TilingRenderPolicyST::SetRenderFn(TRenderFn renderFn)
{
RenderPolicy::SetRenderFn(renderFn);
unsigned tileWidth = m_resourceManager->params().m_renderTargetTexturesParams.m_texWidth;
unsigned tileHeight = m_resourceManager->params().m_renderTargetTexturesParams.m_texHeight;
m_tileRenderer.reset(new TileRenderer(GetPlatform().SkinName(),
m_maxTilesCount,
1, //GetPlatform().CpuCores(),
m_bgColor,
renderFn,
m_primaryRC,
m_resourceManager,
GetPlatform().VisualScale(),
&m_glQueue));
shared_ptr<yg::gl::RenderBuffer> depthBuffer(new yg::gl::RenderBuffer(tileWidth, tileHeight, true));
frameBuffer->setDepthBuffer(depthBuffer);
m_coverageGenerator.reset(new CoverageGenerator(GetPlatform().TileSize(),
GetPlatform().ScaleEtalonSize(),
m_tileRenderer.get(),
m_windowHandle,
m_primaryRC,
m_resourceManager
));
}
p = DrawerYG::Params();
void TilingRenderPolicyST::BeginFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & s)
{
m_IsDebugging = false;
if (m_IsDebugging)
LOG(LINFO, ("-------BeginFrame-------"));
}
p.m_resourceManager = m_resourceManager;
p.m_frameBuffer = frameBuffer;
p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID();
p.m_threadID = 0;
p.m_skinName = GetPlatform().SkinName();
p.m_visualScale = GetPlatform().VisualScale();
void TilingRenderPolicyST::EndFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & s)
{
ScreenCoverage * curCvg = &m_coverageGenerator->CurrentCoverage();
curCvg->EndFrame(e->drawer()->screen().get());
m_coverageGenerator->Mutex().Unlock();
m_tileDrawer = make_shared_ptr(new DrawerYG(p));
m_tileDrawer->onSize(tileWidth, tileHeight);
if (m_IsDebugging)
LOG(LINFO, ("-------EndFrame-------"));
}
m2::RectI renderRect(1, 1, tileWidth - 1, tileWidth - 1);
m_tileScreen.OnSize(renderRect);
bool TilingRenderPolicyST::NeedRedraw() const
{
return RenderPolicy::NeedRedraw() || !m_glQueue.Empty();
}
void TilingRenderPolicyST::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & currentScreen)
{
m_resourceManager->mergeFreeResources();
RenderQueuedCommands(e->drawer()->screen().get());
DrawerYG * pDrawer = e->drawer();
pDrawer->screen()->clear(m_bgColor);
m_infoLayer.clear();
m_coverageGenerator->AddCoverScreenTask(currentScreen);
m_tiler.seed(currentScreen,
currentScreen.GlobalRect().GetGlobalRect().Center());
m_coverageGenerator->Mutex().Lock();
vector<Tiler::RectInfo> visibleTiles;
m_tiler.visibleTiles(visibleTiles);
ScreenCoverage * curCvg = &m_coverageGenerator->CurrentCoverage();
for (unsigned i = 0; i < visibleTiles.size(); ++i)
{
Tiler::RectInfo ri = visibleTiles[i];
curCvg->Draw(pDrawer->screen().get(), currentScreen);
}
m_tileCache.readLock();
TileRenderer & TilingRenderPolicyST::GetTileRenderer()
{
return *m_tileRenderer.get();
}
if (m_tileCache.hasTile(ri))
{
m_tileCache.touchTile(ri);
Tile tile = m_tileCache.getTile(ri);
m_tileCache.readUnlock();
void TilingRenderPolicyST::StartScale()
{
m_isScaling = true;
}
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_infoLayer.merge(*tile.m_infoLayer.get(), tile.m_tileScreen.PtoGMatrix() * currentScreen.GtoPMatrix());
}
else
{
m_tileCache.readUnlock();
shared_ptr<PaintEvent> paintEvent(new PaintEvent(m_tileDrawer.get()));
shared_ptr<yg::gl::BaseTexture> tileTarget = m_resourceManager->renderTargetTextures()->Reserve();
shared_ptr<yg::InfoLayer> tileInfoLayer(new yg::InfoLayer());
m_tileDrawer->screen()->setRenderTarget(tileTarget);
m_tileDrawer->screen()->setInfoLayer(tileInfoLayer);
m_tileDrawer->beginFrame();
yg::Color c = m_bgColor;
m_tileDrawer->clear(yg::Color(c.r, c.g, c.b, 0));
unsigned tileWidth = m_resourceManager->params().m_renderTargetTexturesParams.m_texWidth;
unsigned tileHeight = m_resourceManager->params().m_renderTargetTexturesParams.m_texHeight;
m2::RectI renderRect(1, 1, tileWidth - 1, tileHeight - 1);
m_tileDrawer->screen()->setClipRect(renderRect);
m_tileDrawer->clear(c);
m_tileScreen.SetFromRect(m2::AnyRectD(ri.m_rect));
m2::RectD selectRect;
m2::RectD clipRect;
double inflationSize = 24 * GetPlatform().VisualScale();
m_tileScreen.PtoG(m2::RectD(renderRect), selectRect);
m_tileScreen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), clipRect);
m_renderFn(paintEvent,
m_tileScreen,
selectRect,
clipRect,
ri.m_drawScale);
m_tileDrawer->endFrame();
m_tileDrawer->screen()->resetInfoLayer();
Tile tile(tileTarget, tileInfoLayer, m_tileScreen, ri, 0);
m_tileCache.writeLock();
m_tileCache.addTile(ri, TileCache::Entry(tile, m_resourceManager));
m_tileCache.writeUnlock();
m_tileCache.readLock();
m_tileCache.touchTile(ri);
tile = m_tileCache.getTile(ri);
m_tileCache.readUnlock();
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_windowHandle->invalidate();
}
}
void TilingRenderPolicyST::StopScale()
{
m_isScaling = false;
}
bool TilingRenderPolicyST::IsTiling() const
{
return true;
}
void TilingRenderPolicyST::RenderQueuedCommands(yg::gl::Screen * screen)
{
if (!m_state)
{
m_state = screen->createState();
m_state->m_isDebugging = m_IsDebugging;
}
screen->getState(m_state.get());
m_curState = m_state;
unsigned cmdProcessed = 0;
unsigned const maxCmdPerFrame = 10000;
m_glQueue.ProcessList(bind(&TilingRenderPolicyST::ProcessRenderQueue, this, _1, maxCmdPerFrame));
cmdProcessed = m_frameGLQueue.size();
for (list<yg::gl::Renderer::Packet>::iterator it = m_frameGLQueue.begin(); it != m_frameGLQueue.end(); ++it)
{
if (it->m_state)
{
it->m_state->m_isDebugging = m_IsDebugging;
it->m_state->apply(m_curState.get());
// OGLCHECK(glFinish());
m_curState = it->m_state;
}
it->m_command->setIsDebugging(m_IsDebugging);
it->m_command->perform();
// OGLCHECK(glFinish());
}
/// should clear to release resources, refered from the stored commands.
m_frameGLQueue.clear();
if (m_IsDebugging)
{
LOG(LINFO, ("processed", cmdProcessed, "commands"));
LOG(LINFO, (m_glQueue.Size(), "commands left"));
}
{
threads::ConditionGuard guard(m_glCondition);
if (m_glQueue.Empty())
guard.Signal();
}
// OGLCHECK(glFinish());
m_state->apply(m_curState.get());
// OGLCHECK(glFinish());
}
void TilingRenderPolicyST::ProcessRenderQueue(list<yg::gl::Renderer::Packet> & renderQueue, int maxPackets)
{
m_frameGLQueue.clear();
if (maxPackets == -1)
{
m_frameGLQueue = renderQueue;
renderQueue.clear();
}
else
{
if (renderQueue.empty())
m_glCondition.Signal();
else
{
/// searching for "frame boundary" markers (empty packets)
list<yg::gl::Renderer::Packet>::iterator first = renderQueue.begin();
list<yg::gl::Renderer::Packet>::iterator last = renderQueue.begin();
int packetsLeft = maxPackets;
while ((packetsLeft != 0) && (last != renderQueue.end()))
{
yg::gl::Renderer::Packet p = *last;
if ((p.m_command == 0) && (p.m_state == 0))
{
if (m_IsDebugging)
LOG(LINFO, ("found frame boundary"));
/// found frame boundary, copying
copy(first, last++, back_inserter(m_frameGLQueue));
/// erasing from the main queue
renderQueue.erase(first, last);
first = renderQueue.begin();
last = renderQueue.begin();
}
else
++last;
--packetsLeft;
}
}
}
}

60
map/tiling_render_policy_st.hpp
View file

@ -1,38 +1,60 @@
#pragma once
#include "render_policy.hpp"
#include "drawer_yg.hpp"
#include "tile_renderer.hpp"
#include "coverage_generator.hpp"
#include "tiler.hpp"
#include "tile_cache.hpp"
#include "screen_coverage.hpp"
#include "render_policy.hpp"
#include "../yg/info_layer.hpp"
#include "../std/shared_ptr.hpp"
#include "../geometry/screenbase.hpp"
class WindowHandle;
class VideoTimer;
#include "../std/scoped_ptr.hpp"
namespace yg
{
namespace gl
{
class Screen;
class RenderContext;
}
class ResourceManager;
}
class WindowHandle;
class TilingRenderPolicyST : public RenderPolicy
{
private:
shared_ptr<DrawerYG> m_tileDrawer;
ScreenBase m_tileScreen;
scoped_ptr<TileRenderer> m_tileRenderer;
yg::InfoLayer m_infoLayer;
scoped_ptr<CoverageGenerator> m_coverageGenerator;
TileCache m_tileCache;
Tiler m_tiler;
ScreenBase m_currentScreen;
bool m_isScaling;
int m_maxTilesCount;
/// --- COPY/PASTE HERE ---
ThreadedList<yg::gl::Renderer::Packet> m_glQueue;
list<yg::gl::Renderer::Packet> m_frameGLQueue;
threads::Condition m_glCondition;
shared_ptr<yg::gl::Screen::BaseState> m_curState;
shared_ptr<yg::gl::Renderer::BaseState> m_state;
void ProcessRenderQueue(list<yg::gl::Renderer::Packet> & renderQueue, int maxPackets);
bool m_IsDebugging;
void RenderQueuedCommands(yg::gl::Screen * screen);
protected:
TileRenderer & GetTileRenderer();
public:
@ -41,7 +63,15 @@ public:
yg::ResourceManager::Params const & rmParams,
shared_ptr<yg::gl::RenderContext> const & primaryRC);
void DrawFrame(shared_ptr<PaintEvent> const & paintEvent, ScreenBase const & screenBase);
void BeginFrame(shared_ptr<PaintEvent> const & ev, ScreenBase const & s);
void DrawFrame(shared_ptr<PaintEvent> const & ev, ScreenBase const & s);
void EndFrame(shared_ptr<PaintEvent> const & ev, ScreenBase const & s);
virtual void StartScale();
virtual void StopScale();
bool NeedRedraw() const;
bool IsTiling() const;
void SetRenderFn(TRenderFn renderFn);
};

10
yg/blitter.cpp
View file

@ -114,7 +114,13 @@ namespace yg
yg::gl::Storage storage = resourceManager()->multiBlitStorages()->Reserve();
Vertex * pointsData = (Vertex*)storage.m_vertices->lock();
/// TODO : Bad lock/unlock checking pattern. Should refactor
if (!storage.m_vertices->isLocked())
storage.m_vertices->lock();
if (!storage.m_indices->isLocked())
storage.m_indices->lock();
Vertex * pointsData = (Vertex*)storage.m_vertices->data();
for (size_t i = 0; i < s * 4; ++i)
{
@ -135,7 +141,7 @@ namespace yg
OGLCHECK(glDisable(GL_DEPTH_TEST));
OGLCHECK(glDepthMask(GL_FALSE));
memcpy(storage.m_indices->lock(), &idxData[0], idxData.size() * sizeof(unsigned short));
memcpy(storage.m_indices->data(), &idxData[0], idxData.size() * sizeof(unsigned short));
storage.m_indices->unlock();
storage.m_indices->makeCurrent();

7
yg/render_state_updater.cpp
View file

@ -155,6 +155,8 @@ namespace yg
command2->m_renderState = m_renderState;
processCommand(command2);
markFrameBoundary();
}
void RenderStateUpdater::beginFrame()
@ -178,8 +180,11 @@ namespace yg
void RenderStateUpdater::endFrame()
{
if (m_renderState)
if ((m_renderState) && (m_indicesCount))
updateActualTarget();
else
markFrameBoundary();
m_indicesCount = 0;
m_updateTimer.Reset();
base_t::endFrame();

6
yg/renderer.cpp
View file

@ -401,5 +401,11 @@ namespace yg
{
return m_renderQueue;
}
void Renderer::markFrameBoundary()
{
if (m_renderQueue)
m_renderQueue->PushBack(Packet());
}
}
}

7
yg/renderer.hpp
View file

@ -66,6 +66,8 @@ namespace yg
shared_ptr<Command> const & command);
};
typedef ThreadedList<Packet> PacketsQueue;
struct ClearCommand : Command
{
yg::Color m_color;
@ -93,7 +95,7 @@ namespace yg
shared_ptr<ResourceManager> m_resourceManager;
shared_ptr<FrameBuffer> m_frameBuffer;
bool m_isDebugging;
ThreadedList<Packet> * m_renderQueue;
PacketsQueue * m_renderQueue;
Params();
};
@ -156,6 +158,9 @@ namespace yg
void processCommand(shared_ptr<Command> const & command);
ThreadedList<Packet> * renderQueue();
/// insert empty packet into glQueue to mark the frame boundary
void markFrameBoundary();
};
}
}