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

removed RenderPolicyMT, RenderPolicyST, and non-USING_GLSL code.

Browse source
This commit is contained in:
rachytski 2012-10-25 14:46:03 +03:00 • committed by Alex Zolotarev
parent e217147260
commit 9d92b985d4
19 changed files with 10 additions and 1678 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
iphone/Maps/Classes/RenderContext.mm
View file

@ -13,13 +13,11 @@ namespace iphone
{
RenderContext::RenderContext()
{
//m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
}
RenderContext::RenderContext(RenderContext * renderContext)
{
//m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1 sharegroup:renderContext->m_context.sharegroup];
m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2 sharegroup:renderContext->m_context.sharegroup];
}

173
map/basic_render_policy.cpp
View file

@ -1,173 +0,0 @@
#include "basic_render_policy.hpp"
#include "queued_renderer.hpp"
#include "render_queue.hpp"
#include "drawer_yg.hpp"
#include "events.hpp"
#include "../yg/render_state.hpp"
#include "../geometry/transformations.hpp"
BasicRenderPolicy::BasicRenderPolicy(Params const & p,
bool doSupportRotation,
size_t idCacheSize,
shared_ptr<QueuedRenderer> const & queuedRenderer)
: RenderPolicy(p, doSupportRotation, idCacheSize),
m_QueuedRenderer(queuedRenderer),
m_DoAddCommand(true)
{
}
void BasicRenderPolicy::SetRenderFn(TRenderFn renderFn)
{
RenderPolicy::SetRenderFn(renderFn);
m_RenderQueue->initializeGL(m_primaryRC, m_resourceManager);
}
void BasicRenderPolicy::SetCountryNameFn(TCountryNameFn countryNameFn)
{
RenderPolicy::SetCountryNameFn(countryNameFn);
m_RenderQueue->SetCountryNameFn(countryNameFn);
}
m2::RectI const BasicRenderPolicy::OnSize(int w, int h)
{
RenderPolicy::OnSize(w, h);
m_RenderQueue->OnSize(w, h);
m2::PointU pt = m_RenderQueue->renderState().coordSystemShift();
return m2::RectI(pt.x, pt.y, pt.x + w, pt.y + h);
}
void BasicRenderPolicy::BeginFrame(shared_ptr<PaintEvent> const & e,
ScreenBase const & s)
{
RenderPolicy::BeginFrame(e, s);
if (m_QueuedRenderer)
m_QueuedRenderer->BeginFrame();
}
void BasicRenderPolicy::EndFrame(shared_ptr<PaintEvent> const & e,
ScreenBase const & s)
{
m_RenderQueue->renderState().m_mutex->Unlock();
if (m_QueuedRenderer)
m_QueuedRenderer->EndFrame();
}
void BasicRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & e,
ScreenBase const & s)
{
if (m_QueuedRenderer)
{
m_QueuedRenderer->DrawFrame();
m_resourceManager->updatePoolState();
}
bool doForceUpdate = DoForceUpdate();
bool doIntersectInvalidRect = s.GlobalRect().IsIntersect(GetInvalidRect());
m_RenderQueue->renderStatePtr()->m_doRepaintAll = doForceUpdate;
if (m_DoAddCommand)
{
if (s != m_RenderQueue->renderState().m_actualScreen)
m_RenderQueue->AddCommand(m_renderFn, s);
else
if (doForceUpdate && doIntersectInvalidRect)
m_RenderQueue->AddCommand(m_renderFn, s);
}
SetForceUpdate(false);
DrawerYG * pDrawer = e->drawer();
e->drawer()->beginFrame();
e->drawer()->screen()->clear(m_bgColor);
m_RenderQueue->renderState().m_mutex->Lock();
SetOverlay(m_RenderQueue->renderState().m_currentOverlay);
if (m_RenderQueue->renderState().m_actualTarget.get() != 0)
{
m2::PointD const ptShift = m_RenderQueue->renderState().coordSystemShift(false);
math::Matrix<double, 3, 3> m = m_RenderQueue->renderState().m_actualScreen.PtoGMatrix() * s.GtoPMatrix();
m = math::Shift(m, -ptShift);
// rounding shift to pixel boundary to remove "blitting blurriness".
m(2, 0) = floor(m(2, 0));
m(2, 1) = floor(m(2, 1));
pDrawer->screen()->blit(m_RenderQueue->renderState().m_actualTarget, m);
}
e->drawer()->endFrame();
}
void BasicRenderPolicy::StartDrag()
{
m_DoAddCommand = false;
RenderPolicy::StartDrag();
}
void BasicRenderPolicy::StopDrag()
{
m_DoAddCommand = true;
RenderPolicy::StopDrag();
}
void BasicRenderPolicy::StartScale()
{
m_DoAddCommand = false;
RenderPolicy::StartScale();
}
void BasicRenderPolicy::StopScale()
{
m_DoAddCommand = true;
RenderPolicy::StopScale();
}
bool BasicRenderPolicy::IsEmptyModel() const
{
return m_RenderQueue->renderStatePtr()->m_isEmptyModelActual;
}
string const BasicRenderPolicy::GetCountryName() const
{
return m_RenderQueue->renderStatePtr()->m_countryNameActual;
}
RenderQueue & BasicRenderPolicy::GetRenderQueue()
{
return *m_RenderQueue.get();
}
bool BasicRenderPolicy::NeedRedraw() const
{
if (RenderPolicy::NeedRedraw())
return true;
if (m_QueuedRenderer && m_QueuedRenderer->NeedRedraw())
return true;
return false;
}
int BasicRenderPolicy::InsertBenchmarkFence()
{
return m_RenderQueue->InsertBenchmarkFence();
}
void BasicRenderPolicy::JoinBenchmarkFence(int fenceID)
{
m_RenderQueue->JoinBenchmarkFence(fenceID);
}

56
map/basic_render_policy.hpp
View file

@ -1,56 +0,0 @@
#pragma once
#include "../std/shared_ptr.hpp"
#include "render_policy.hpp"
class QueuedRenderer;
class RenderQueue;
/// This is a base class for both multithreaded and singlethreaded rendering policies
/// that uses a double buffering scheme.
/// primary OpenGL thread only blits frontBuffer(RenderState::actualTarget),
/// while another thread renders scene on the backBuffer and swaps it
/// with frontBuffer periodically
class BasicRenderPolicy : public RenderPolicy
{
protected:
shared_ptr<QueuedRenderer> m_QueuedRenderer;
shared_ptr<RenderQueue> m_RenderQueue;
bool m_DoAddCommand;
public:
BasicRenderPolicy(Params const & p,
bool doSupportRotation,
size_t idCacheSize,
shared_ptr<QueuedRenderer> const & queuedRenderer = shared_ptr<QueuedRenderer>());
void BeginFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & s);
void DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & s);
void EndFrame(shared_ptr<PaintEvent> const & e, ScreenBase const & s);
m2::RectI const OnSize(int w, int h);
void StartDrag();
void StopDrag();
void StartScale();
void StopScale();
bool IsEmptyModel() const;
string const GetCountryName() const;
RenderQueue & GetRenderQueue();
void SetRenderFn(TRenderFn renderFn);
void SetCountryNameFn(TCountryNameFn countryNameFn);
bool NeedRedraw() const;
/// benchmarking protocol
int InsertBenchmarkFence();
void JoinBenchmarkFence(int fenceID);
};

10
map/map.pro
View file

@ -27,15 +27,11 @@ HEADERS += \
tiling_render_policy_mt.hpp \
tiling_render_policy_st.hpp \
benchmark_engine.hpp \
render_policy_st.hpp \
coverage_generator.hpp \
tiler.hpp \
tile.hpp \
tile_cache.hpp \
screen_coverage.hpp \
basic_render_policy.hpp \
render_queue.hpp \
render_queue_routine.hpp \
ruler.hpp \
measurement_utils.hpp \
simple_render_policy.hpp \
@ -43,7 +39,6 @@ HEADERS += \
test_render_policy.hpp \
queued_renderer.hpp \
basic_tiling_render_policy.hpp \
render_policy_mt.hpp \
bookmark.hpp \
tile_set.hpp \
geourl_process.hpp \
@ -69,15 +64,11 @@ SOURCES += \
tiling_render_policy_st.cpp \
tiling_render_policy_mt.cpp \
benchmark_engine.cpp \
render_policy_st.cpp \
coverage_generator.cpp \
tiler.cpp \
tile_cache.cpp \
tile.cpp \
screen_coverage.cpp \
basic_render_policy.cpp \
render_queue_routine.cpp \
render_queue.cpp \
ruler.cpp \
measurement_utils.cpp \
window_handle.cpp \
@ -87,7 +78,6 @@ SOURCES += \
queued_renderer.cpp \
events.cpp \
basic_tiling_render_policy.cpp \
render_policy_mt.cpp \
address_finder.cpp \
tile_set.cpp \
geourl_process.cpp \

3
map/render_policy.cpp
View file

@ -3,10 +3,7 @@
#include "render_policy.hpp"
#include "window_handle.hpp"
#include "test_render_policy.hpp"
#include "basic_render_policy.hpp"
#include "simple_render_policy.hpp"
#include "render_policy_st.hpp"
#include "render_policy_mt.hpp"
#include "tiling_render_policy_st.hpp"
#include "tiling_render_policy_mt.hpp"

149
map/render_policy_mt.cpp
View file

@ -1,149 +0,0 @@
#include "render_policy_mt.hpp"
#include "../yg/internal/opengl.hpp"
#include "../yg/skin.hpp"
#include "../platform/platform.hpp"
#include "window_handle.hpp"
#include "render_queue.hpp"
RenderPolicyMT::RenderPolicyMT(RenderPolicy::Params const & p)
: BasicRenderPolicy(p, false, 1)
{
yg::ResourceManager::Params rmp = p.m_rmParams;
rmp.checkDeviceCaps();
rmp.m_primaryStoragesParams = yg::ResourceManager::StoragePoolParams(5000 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10000 * sizeof(unsigned short),
sizeof(unsigned short),
1,
true,
true,
10,
"primaryStorage",
false,
true);
rmp.m_smallStoragesParams = yg::ResourceManager::StoragePoolParams(500 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
1000 * sizeof(unsigned short),
sizeof(unsigned short),
5,
true,
true,
5,
"smallStorage",
false,
true);
rmp.m_blitStoragesParams = yg::ResourceManager::StoragePoolParams(10 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10 * sizeof(unsigned short),
sizeof(unsigned short),
1,
true,
true,
1,
"blitStorage",
false,
true);
rmp.m_guiThreadStoragesParams = yg::ResourceManager::StoragePoolParams(300 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
600 * sizeof(unsigned short),
sizeof(unsigned short),
2,
true,
true,
1,
"guiThreadStorage",
false,
true);
rmp.m_primaryTexturesParams = yg::ResourceManager::TexturePoolParams(512,
256,
1,
rmp.m_texFormat,
true,
true,
true,
1,
"primaryTexture",
false,
true);
rmp.m_fontTexturesParams = yg::ResourceManager::TexturePoolParams(512,
256,
1,
rmp.m_texFormat,
true,
true,
true,
1,
"fontTexture",
false,
true);
rmp.m_guiThreadTexturesParams = yg::ResourceManager::TexturePoolParams(256,
128,
2,
rmp.m_texFormat,
true,
true,
true,
1,
"guiThreadTexture",
false,
true);
rmp.m_glyphCacheParams = yg::ResourceManager::GlyphCacheParams("unicode_blocks.txt",
"fonts_whitelist.txt",
"fonts_blacklist.txt",
2 * 1024 * 1024,
3,
1);
rmp.m_useSingleThreadedOGL = false;
rmp.fitIntoLimits();
m_resourceManager.reset(new yg::ResourceManager(rmp));
Platform::FilesList fonts;
GetPlatform().GetFontNames(fonts);
m_resourceManager->addFonts(fonts);
DrawerYG::Params dp;
dp.m_frameBuffer = make_shared_ptr(new yg::gl::FrameBuffer(p.m_useDefaultFB));
dp.m_resourceManager = m_resourceManager;
dp.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID();
dp.m_skin = make_shared_ptr(yg::loadSkin(m_resourceManager, SkinName()));
dp.m_visualScale = VisualScale();
dp.m_isSynchronized = false;
dp.m_useGuiResources = true;
dp.m_fastSolidPath = true;
m_drawer.reset(new DrawerYG(dp));
m_windowHandle.reset(new WindowHandle());
m_windowHandle->setUpdatesEnabled(false);
m_windowHandle->setRenderPolicy(this);
m_windowHandle->setVideoTimer(p.m_videoTimer);
m_windowHandle->setRenderContext(p.m_primaryRC);
m_RenderQueue.reset(new RenderQueue(SkinName(),
false,
true,
0.1,
false,
ScaleEtalonSize(),
VisualScale(),
m_bgColor));
m_RenderQueue->AddWindowHandle(m_windowHandle);
}

9
map/render_policy_mt.hpp
View file

@ -1,9 +0,0 @@
#pragma once
#include "basic_render_policy.hpp"
class RenderPolicyMT : public BasicRenderPolicy
{
public:
RenderPolicyMT(Params const & p);
};

169
map/render_policy_st.cpp
View file

@ -1,169 +0,0 @@
#include "render_policy_st.hpp"
#include "../platform/platform.hpp"
#include "../yg/internal/opengl.hpp"
#include "../yg/skin.hpp"
#include "queued_renderer.hpp"
#include "window_handle.hpp"
#include "render_queue.hpp"
RenderPolicyST::RenderPolicyST(Params const & p)
: BasicRenderPolicy(p, false, 1, make_shared_ptr(new QueuedRenderer(1)))
{
yg::ResourceManager::Params rmp = p.m_rmParams;
rmp.checkDeviceCaps();
rmp.m_primaryStoragesParams = yg::ResourceManager::StoragePoolParams(5000 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10000 * sizeof(unsigned short),
sizeof(unsigned short),
4,
true,
false,
2,
"primaryStorage",
false,
false);
rmp.m_smallStoragesParams = yg::ResourceManager::StoragePoolParams(2000 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
4000 * sizeof(unsigned short),
sizeof(unsigned short),
4,
true,
false,
1,
"smallStorage",
false,
false);
rmp.m_blitStoragesParams = yg::ResourceManager::StoragePoolParams(10 * sizeof(yg::gl::Vertex),
sizeof(yg::gl::Vertex),
10 * sizeof(unsigned short),
sizeof(unsigned short),
50,
true,
true,
1,
"blitStorage",
false,
false);
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",
false,
false);
rmp.m_primaryTexturesParams = yg::ResourceManager::TexturePoolParams(512,
256,
6,
rmp.m_texFormat,
true,
true,
true,
1,
"primaryTexture",
false,
false);
rmp.m_fontTexturesParams = yg::ResourceManager::TexturePoolParams(512,
256,
6,
rmp.m_texFormat,
true,
true,
true,
1,
"fontTextures",
false,
false);
rmp.m_guiThreadTexturesParams = yg::ResourceManager::TexturePoolParams(256,
128,
4,
rmp.m_texFormat,
true,
true,
true,
1,
"guiThreadTexture",
false,
false);
rmp.m_glyphCacheParams = yg::ResourceManager::GlyphCacheParams("unicode_blocks.txt",
"fonts_whitelist.txt",
"fonts_blacklist.txt",
2 * 1024 * 1024,
2,
1);
rmp.m_useSingleThreadedOGL = true;
rmp.fitIntoLimits();
m_resourceManager.reset(new yg::ResourceManager(rmp));
m_QueuedRenderer->SetSinglePipelineProcessing(m_resourceManager->useReadPixelsToSynchronize());
Platform::FilesList fonts;
GetPlatform().GetFontNames(fonts);
m_resourceManager->addFonts(fonts);
DrawerYG::Params dp;
dp.m_frameBuffer = make_shared_ptr(new yg::gl::FrameBuffer(p.m_useDefaultFB));
dp.m_resourceManager = m_resourceManager;
dp.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID();
dp.m_skin = make_shared_ptr(yg::loadSkin(m_resourceManager, SkinName()));
dp.m_visualScale = VisualScale();
dp.m_isSynchronized = false;
dp.m_useGuiResources = true;
dp.m_fastSolidPath = false;
m_drawer.reset();
m_drawer.reset(new DrawerYG(dp));
m_windowHandle.reset();
m_windowHandle.reset(new WindowHandle());
m_windowHandle->setUpdatesEnabled(false);
m_windowHandle->setRenderPolicy(this);
m_windowHandle->setVideoTimer(p.m_videoTimer);
m_windowHandle->setRenderContext(p.m_primaryRC);
m_RenderQueue.reset();
m_RenderQueue.reset(new RenderQueue(SkinName(),
false,
false,
0.1,
false,
ScaleEtalonSize(),
VisualScale(),
m_bgColor));
m_RenderQueue->AddWindowHandle(m_windowHandle);
m_RenderQueue->SetGLQueue(m_QueuedRenderer->GetPacketsQueue(0));
}
RenderPolicyST::~RenderPolicyST()
{
LOG(LINFO, ("destroying RenderPolicyST"));
m_QueuedRenderer->CancelQueuedCommands(0);
LOG(LINFO, ("shutting down renderQueue"));
m_RenderQueue.reset();
LOG(LINFO, ("PartialRenderPolicy destroyed"));
}

11
map/render_policy_st.hpp
View file

@ -1,11 +0,0 @@
#pragma once
#include "basic_render_policy.hpp"
class RenderPolicyST : public BasicRenderPolicy
{
public:
RenderPolicyST(Params const & p);
~RenderPolicyST();
};

147
map/render_queue.cpp
View file

@ -1,147 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "render_queue.hpp"
#include "../yg/render_state.hpp"
#include "../yg/rendercontext.hpp"
RenderQueue::RenderQueue(
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking,
unsigned scaleEtalonSize,
double visualScale,
yg::Color const & bgColor
)
: m_renderState(new yg::gl::RenderState()),
m_hasPendingResize(false)
{
m_renderState->m_surfaceWidth = 100;
m_renderState->m_surfaceHeight = 100;
m_renderState->m_textureWidth = 256;
m_renderState->m_textureHeight = 256;
m_renderState->m_duration = 0;
m_renderState->m_isEmptyModelCurrent = false;
m_renderState->m_isEmptyModelActual = false;
m_routine = new RenderQueueRoutine(
m_renderState,
skinName,
isMultiSampled,
doPeriodicalUpdate,
updateInterval,
isBenchmarking,
scaleEtalonSize,
visualScale,
bgColor);
}
void RenderQueue::initializeGL(shared_ptr<yg::gl::RenderContext> const & primaryContext,
shared_ptr<yg::ResourceManager> const & resourceManager)
{
m_resourceManager = resourceManager;
m_routine->initializeGL(primaryContext->createShared(),
m_resourceManager);
if (m_hasPendingResize)
{
m_routine->onSize(m_savedWidth, m_savedHeight);
m_hasPendingResize = false;
}
m_renderQueueThread.Create(m_routine);
}
RenderQueue::~RenderQueue()
{
m_renderQueueThread.Cancel();
delete m_routine;
}
void RenderQueue::AddCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenBase const & frameScreen)
{
m_routine->addCommand(fn, frameScreen);
}
void RenderQueue::SetRedrawAll()
{
m_renderState->m_doRepaintAll = true;
}
void RenderQueue::SetCountryNameFn(RenderQueueRoutine::TCountryNameFn fn)
{
m_routine->SetCountryNameFn(fn);
}
void RenderQueue::AddWindowHandle(shared_ptr<WindowHandle> const & windowHandle)
{
m_routine->addWindowHandle(windowHandle);
}
void RenderQueue::OnSize(size_t w, size_t h)
{
m_renderState->onSize(w, h);
if (!m_resourceManager)
{
m_hasPendingResize = true;
m_savedWidth = w;
m_savedHeight = h;
}
else
m_routine->onSize(w, h);
}
yg::gl::RenderState const RenderQueue::CopyState() const
{
yg::gl::RenderState state;
m_renderState->copyTo(state);
return state;
}
yg::gl::RenderState const & RenderQueue::renderState() const
{
return *m_renderState.get();
}
shared_ptr<yg::gl::RenderState> const & RenderQueue::renderStatePtr() const
{
return m_renderState;
}
void RenderQueue::memoryWarning()
{
m_routine->memoryWarning();
}
void RenderQueue::enterBackground()
{
m_routine->enterBackground();
}
void RenderQueue::enterForeground()
{
m_routine->enterForeground();
}
void RenderQueue::WaitForEmptyAndFinished()
{
m_routine->waitForEmptyAndFinished();
}
void RenderQueue::SetGLQueue(yg::gl::PacketsQueue * glQueue)
{
m_routine->setGLQueue(glQueue);
}
int RenderQueue::InsertBenchmarkFence()
{
return m_routine->insertBenchmarkFence();
}
void RenderQueue::JoinBenchmarkFence(int id)
{
return m_routine->joinBenchmarkFence(id);
}

86
map/render_queue.hpp
View file

@ -1,86 +0,0 @@
#pragma once
#include "../base/thread.hpp"
#include "../base/threaded_list.hpp"
#include "../yg/renderer.hpp"
#include "../geometry/screenbase.hpp"
#include "../std/shared_ptr.hpp"
#include "render_queue_routine.hpp"
namespace yg
{
class ResourceManager;
namespace gl
{
class RenderState;
class RenderContext;
}
}
class WindowHandle;
class RenderQueue
{
private:
friend class RenderQueueRoutine;
threads::Thread m_renderQueueThread;
shared_ptr<yg::gl::RenderState> m_renderState;
shared_ptr<yg::ResourceManager> m_resourceManager;
RenderQueueRoutine * m_routine;
bool m_hasPendingResize;
int m_savedWidth;
int m_savedHeight;
public:
/// constructor.
RenderQueue(string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking,
unsigned scaleEtalonSize,
double visualScale,
yg::Color const & bgColor);
/// destructor.
~RenderQueue();
/// set the primary context. it starts the rendering thread.
void initializeGL(shared_ptr<yg::gl::RenderContext> const & primaryContext,
shared_ptr<yg::ResourceManager> const & resourceManager);
/// add command to the commands queue.
void AddCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenBase const & frameScreen);
void SetRedrawAll();
void SetCountryNameFn(RenderQueueRoutine::TCountryNameFn fn);
void SetVisualScale(double visualScale);
/// add window handle to notify when rendering operation finishes
void AddWindowHandle(shared_ptr<WindowHandle> const & windowHandle);
/// process resize request
void OnSize(size_t w, size_t h);
/// copy primary render state
yg::gl::RenderState const CopyState() const;
shared_ptr<yg::gl::RenderState> const & renderStatePtr() const;
yg::gl::RenderState const & renderState() const;
/// free all possible memory caches
void memoryWarning();
/// free all possible memory caches, opengl resources,
/// and make sure no opengl call will be made in background
void enterBackground();
/// load all necessary memory caches and opengl resources.
void enterForeground();
void WaitForEmptyAndFinished();
void SetGLQueue(yg::gl::PacketsQueue * glQueue);
int InsertBenchmarkFence();
void JoinBenchmarkFence(int id);
};

635
map/render_queue_routine.cpp
View file

@ -1,635 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "../base/mutex.hpp"
#include "../base/timer.hpp"
#include "../base/logging.hpp"
#include "../std/bind.hpp"
#include "../yg/internal/opengl.hpp"
#include "../yg/render_state.hpp"
#include "../yg/rendercontext.hpp"
#include "../yg/framebuffer.hpp"
#include "../yg/renderbuffer.hpp"
#include "../yg/texture.hpp"
#include "../yg/resource_manager.hpp"
#include "../yg/screen.hpp"
#include "../yg/pen_info.hpp"
#include "../yg/skin.hpp"
#include "../indexer/scales.hpp"
#include "events.hpp"
#include "drawer_yg.hpp"
#include "window_handle.hpp"
#include "render_queue_routine.hpp"
RenderQueueRoutine::RenderModelCommand::RenderModelCommand(ScreenBase const & frameScreen,
render_fn_t renderFn)
: m_frameScreen(frameScreen),
m_renderFn(renderFn)
{}
RenderQueueRoutine::RenderQueueRoutine(shared_ptr<yg::gl::RenderState> const & renderState,
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking,
unsigned scaleEtalonSize,
double visualScale,
yg::Color const & bgColor)
: m_fenceManager(2)
{
m_skinName = skinName;
m_visualScale = visualScale;
m_renderState = renderState;
m_renderState->addInvalidateFn(bind(&RenderQueueRoutine::invalidate, this));
m_isMultiSampled = isMultiSampled;
m_doPeriodicalUpdate = doPeriodicalUpdate;
m_updateInterval = updateInterval;
m_isBenchmarking = isBenchmarking;
m_scaleEtalonSize = scaleEtalonSize;
m_bgColor = bgColor;
m_glQueue = 0;
m_currentFenceID = -1;
}
void RenderQueueRoutine::Cancel()
{
IRoutine::Cancel();
{
threads::ConditionGuard guard(m_hasRenderCommands);
if (m_currentRenderCommand != 0)
{
LOG(LDEBUG, ("cancelling current renderCommand in progress"));
m_currentRenderCommand->m_paintEvent->cancel();
}
LOG(LDEBUG, ("waking up the sleeping thread..."));
m_hasRenderCommands.Signal();
}
}
void RenderQueueRoutine::onSize(int w, int h)
{
size_t texW = m_renderState->m_textureWidth;
size_t texH = m_renderState->m_textureHeight;
m_newDepthBuffer.reset();
m_newDepthBuffer.reset(new yg::gl::RenderBuffer(texW, texH, true));
m_newActualTarget = m_resourceManager->createRenderTarget(texW, texH);
m_newBackBuffer = m_resourceManager->createRenderTarget(texW, texH);
}
void RenderQueueRoutine::SetCountryNameFn(TCountryNameFn countryNameFn)
{
m_countryNameFn = countryNameFn;
}
void RenderQueueRoutine::processResize(ScreenBase const & frameScreen)
{
if (m_renderState->m_isResized)
{
size_t texW = m_renderState->m_textureWidth;
size_t texH = m_renderState->m_textureHeight;
m_threadDrawer->onSize(texW, texH);
m_renderState->m_depthBuffer = m_newDepthBuffer;
m_threadDrawer->screen()->setDepthBuffer(m_renderState->m_depthBuffer);
m_newDepthBuffer.reset();
shared_ptr<yg::gl::BaseTexture> oldActualTarget = m_renderState->m_actualTarget;
m_renderState->m_actualTarget.reset();
m_renderState->m_actualTarget = m_newActualTarget;
m_newActualTarget.reset();
m_auxScreen->onSize(texW, texH);
m_auxScreen->setRenderTarget(m_renderState->m_actualTarget);
m_auxScreen->beginFrame();
m_auxScreen->clear(m_bgColor);
if (oldActualTarget != 0)
{
m_auxScreen->blit(oldActualTarget,
m_renderState->m_actualScreen,
frameScreen);
oldActualTarget.reset();
}
m_auxScreen->endFrame();
shared_ptr<yg::gl::BaseTexture> oldBackBuffer = m_renderState->m_backBuffer;
m_renderState->m_backBuffer.reset();
m_renderState->m_backBuffer = m_newBackBuffer;
m_newBackBuffer.reset();
m_auxScreen->setRenderTarget(m_renderState->m_backBuffer);
m_auxScreen->beginFrame();
m_auxScreen->clear(m_bgColor);
if (oldBackBuffer != 0)
{
m_auxScreen->blit(oldBackBuffer,
m_renderState->m_actualScreen,
frameScreen);
oldBackBuffer.reset();
}
m_auxScreen->endFrame();
/// TODO : make as a command
m_renderState->m_actualScreen = frameScreen;
m_renderState->m_isResized = false;
}
}
bool RenderQueueRoutine::getUpdateAreas(
ScreenBase const & oldScreen,
m2::RectI const & oldRect,
ScreenBase const & newScreen,
m2::RectI const & newRect,
vector<m2::RectI> & areas)
{
areas.clear();
if (IsPanningAndRotate(oldScreen, newScreen))
{
m2::RectD o(newScreen.GtoP(oldScreen.PtoG(m2::PointD(oldRect.minX(), oldRect.minY()))),
newScreen.GtoP(oldScreen.PtoG(m2::PointD(oldRect.maxX(), oldRect.maxY()))));
m2::RectD n(newRect);
/// checking two corner cases
if (o.IsRectInside(n))
return false;
if (!o.IsIntersect(n))
{
areas.push_back(newRect);
return true;
}
double leftBarMinX = 0;
double leftBarMaxX = 0;
double rightBarMinX = n.maxX();
double rightBarMaxX = n.maxX();
double topBarMinY = 0;
double topBarMaxY = 0;
double bottomBarMinY = n.maxY();
double bottomBarMaxY = n.maxY();
if (o.minX() > n.minX())
leftBarMaxX = ceil(o.minX());
if (o.maxX() < n.maxX())
rightBarMinX = floor(o.maxX());
if (o.minY() > n.minY())
topBarMaxY = ceil(o.minY());
if (o.maxY() < n.maxY())
bottomBarMinY = floor(o.maxY());
if ((int)leftBarMinX != (int)leftBarMaxX)
areas.push_back(m2::RectI((int)leftBarMinX, (int)topBarMinY, (int)leftBarMaxX, (int)bottomBarMinY));
if ((int)topBarMinY != (int)topBarMaxY)
areas.push_back(m2::RectI((int)leftBarMaxX, (int)topBarMinY, (int)rightBarMaxX, (int)topBarMaxY));
if ((int)rightBarMinX != (int)rightBarMaxX)
areas.push_back(m2::RectI((int)rightBarMinX, (int)topBarMaxY, (int)rightBarMaxX, (int)bottomBarMaxY));
if ((int)bottomBarMinY != (int)bottomBarMaxY)
areas.push_back(m2::RectI((int)leftBarMinX, (int)bottomBarMinY, (int)rightBarMinX, (int)bottomBarMaxY));
return false;
}
else
{
if (m_doPeriodicalUpdate)
areas.push_back(newRect);
else
{
int sx = ( newRect.SizeX() + 4 ) / 5;
int sy = ( newRect.SizeY() + 4 ) / 5;
m2::RectI r(0, 0, sx, sy);
areas.push_back(m2::Offset(r, 2 * sx, 2 * sy));
areas.push_back(m2::Offset(r, 2 * sx, 1 * sy));
areas.push_back(m2::Offset(r, 3 * sx, 1 * sy));
areas.push_back(m2::Offset(r, 3 * sx, 2 * sy));
areas.push_back(m2::Offset(r, 3 * sx, 3 * sy));
areas.push_back(m2::Offset(r, 2 * sx, 3 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 3 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 2 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 1 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 0 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 0 * sy));
areas.push_back(m2::Offset(r, 2 * sx, 0 * sy));
areas.push_back(m2::Offset(r, 3 * sx, 0 * sy));
areas.push_back(m2::Offset(r, 4 * sx, 0 * sy));
areas.push_back(m2::Offset(r, 4 * sx, 1 * sy));
areas.push_back(m2::Offset(r, 4 * sx, 2 * sy));
areas.push_back(m2::Offset(r, 4 * sx, 3 * sy));
areas.push_back(m2::Offset(r, 4 * sx, 4 * sy));
areas.push_back(m2::Offset(r, 3 * sx, 4 * sy));
areas.push_back(m2::Offset(r, 2 * sx, 4 * sy));
areas.push_back(m2::Offset(r, 1 * sx, 4 * sy));
areas.push_back(m2::Offset(r, 0 * sx, 4 * sy));
areas.push_back(m2::Offset(r, 0 * sx, 3 * sy));
areas.push_back(m2::Offset(r, 0 * sx, 2 * sy));
areas.push_back(m2::Offset(r, 0 * sx, 1 * sy));
areas.push_back(m2::Offset(r, 0 * sx, 0 * sy));
}
return true;
}
}
void RenderQueueRoutine::setVisualScale(double visualScale)
{
m_visualScale = visualScale;
}
void RenderQueueRoutine::waitForRenderCommand(list<shared_ptr<RenderModelCommand> > & cmdList,
threads::ConditionGuard & guard)
{
while (cmdList.empty())
{
guard.Wait();
if (IsCancelled())
break;
}
}
void RenderQueueRoutine::Do()
{
if (!m_glQueue)
m_renderContext->makeCurrent();
DrawerYG::Params params;
params.m_resourceManager = m_resourceManager;
params.m_frameBuffer = m_frameBuffer;
params.m_renderState = m_renderState;
params.m_doPeriodicalUpdate = m_doPeriodicalUpdate;
params.m_auxFrameBuffer = m_auxFrameBuffer;
params.m_updateInterval = m_updateInterval;
params.m_skin = make_shared_ptr(yg::loadSkin(m_resourceManager, m_skinName));
params.m_visualScale = m_visualScale;
params.m_threadID = 0;
params.m_glyphCacheID = m_resourceManager->renderThreadGlyphCacheID(0);
params.m_renderQueue = m_glQueue;
/* params.m_isDebugging = true;
params.m_drawPathes = false;
params.m_drawAreas = false;
params.m_drawTexts = false;
params.m_drawSymbols = false;*/
m_threadDrawer = make_shared_ptr(new DrawerYG(params));
yg::gl::Screen::Params auxParams;
auxParams.m_frameBuffer = m_auxFrameBuffer;
auxParams.m_resourceManager = m_resourceManager;
auxParams.m_renderQueue = m_glQueue;
m_auxScreen = make_shared_ptr(new yg::gl::Screen(auxParams));
bool isPanning = false;
bool doRedrawAll = false;
bool fullRectRepaint = false;
/// update areas in pixel coordinates.
vector<m2::RectI> areas;
m2::RectI surfaceRect;
m2::RectI textureRect;
shared_ptr<yg::Overlay> overlay(new yg::Overlay());
overlay->setCouldOverlap(false);
m_threadDrawer->screen()->setOverlay(overlay);
m_renderState->m_currentOverlay = overlay;
while (!IsCancelled())
{
{
threads::ConditionGuard guard(m_hasRenderCommands);
waitForRenderCommand(m_renderCommands, guard);
if (IsCancelled())
{
LOG(LDEBUG, ("thread is cancelled while waiting for a render command"));
break;
}
m_currentRenderCommand = m_renderCommands.front();
m_renderCommands.erase(m_renderCommands.begin());
m_currentRenderCommand->m_paintEvent = make_shared_ptr(new PaintEvent(m_threadDrawer.get()));
/// this prevents the framework from flooding us with a bunch of RenderCommands with the same screen.
{
threads::MutexGuard guard(*m_renderState->m_mutex.get());
m_renderState->m_currentScreen = m_currentRenderCommand->m_frameScreen;
m2::RectI prevRect(0, 0, 0, 0);
ScreenBase prevScreen = m_renderState->m_actualScreen;
if (m_renderState->m_actualTarget != 0)
prevRect = m2::RectI(0, 0,
m_renderState->m_actualTarget->width(),
m_renderState->m_actualTarget->height());
processResize(m_currentRenderCommand->m_frameScreen);
/// saving parameters, which might be changed from the GUI thread for later use.
surfaceRect = m2::RectI(0, 0, m_renderState->m_surfaceWidth, m_renderState->m_surfaceHeight);
textureRect = m2::RectI(0, 0, m_renderState->m_textureWidth, m_renderState->m_textureHeight);
m2::RectI curRect = textureRect;
doRedrawAll = m_renderState->m_doRepaintAll;
fullRectRepaint = false;
if (m_renderState->m_doRepaintAll)
{
areas.clear();
areas.push_back(curRect);
fullRectRepaint = true;
m_threadDrawer->screen()->overlay()->clear();
m_renderState->m_doRepaintAll = false;
}
else
{
fullRectRepaint = getUpdateAreas(prevScreen,
prevRect,
m_currentRenderCommand->m_frameScreen,
curRect,
areas);
/* if ((areas.size() == 1) && (areas[0] == curRect))
fullRectRepaint = true;*/
}
isPanning = IsPanningAndRotate(prevScreen, m_renderState->m_currentScreen);
if (isPanning)
{
math::Matrix<double, 3, 3> offsetM = prevScreen.PtoGMatrix() * m_renderState->m_currentScreen.GtoPMatrix();
m2::RectD oldRect = m2::RectD(m2::PointD(prevRect.minX(), prevRect.minY()) * offsetM,
m2::PointD(prevRect.maxX(), prevRect.maxY()) * offsetM);
m2::RectD redrawTextRect(curRect);
if (!redrawTextRect.Intersect(oldRect))
redrawTextRect = m2::RectD(0, 0, 0, 0);
m_threadDrawer->screen()->overlay()->offset(
m2::PointD(0, 0) * offsetM,
redrawTextRect
);
}
else
{
m_threadDrawer->screen()->overlay()->clear();
m_renderState->m_isEmptyModelCurrent = true;
}
}
}
my::Timer timer;
/// At this point renderQueue->mutex is released to allow
/// main thread to add new rendering tasks and blit already
/// rendered model while the current command is actually rendering.
if (IsCancelled())
{
LOG(LDEBUG, ("cancelled before processing currentRenderCommand"));
}
else if (m_currentRenderCommand != 0)
{
/// this fixes some strange issue with multisampled framebuffer.
/// setRenderTarget should be made here.
m_threadDrawer->screen()->setRenderTarget(m_renderState->m_backBuffer);
m_threadDrawer->beginFrame();
m_threadDrawer->screen()->enableClipRect(true);
m_threadDrawer->screen()->setClipRect(textureRect);
m_threadDrawer->clear(m_bgColor);
if ((isPanning) && (!doRedrawAll))
{
m_threadDrawer->screen()->blit(
m_renderState->m_actualTarget,
m_renderState->m_actualScreen,
m_renderState->m_currentScreen);
}
m_threadDrawer->endFrame();
//m_threadDrawer->screen()->setNeedTextRedraw(isPanning);
ScreenBase const & frameScreen = m_currentRenderCommand->m_frameScreen;
m2::RectD glbRect;
frameScreen.PtoG(m2::RectD(m2::RectD(textureRect).Center() - m2::PointD(m_scaleEtalonSize / 2, m_scaleEtalonSize / 2),
m2::RectD(textureRect).Center() + m2::PointD(m_scaleEtalonSize / 2, m_scaleEtalonSize / 2)),
glbRect);
// frameScreen.PtoG(m2::RectD(surfaceRect), glbRect);
int scaleLevel = scales::GetScaleLevel(glbRect);
bool cumulativeEmptyModelCurrent = true;
for (size_t i = 0; i < areas.size(); ++i)
{
if ((areas[i].SizeX() != 0) && (areas[i].SizeY() != 0))
{
frameScreen.PtoG(m2::Inflate<double>(m2::RectD(areas[i]), 30 * m_visualScale, 30 * m_visualScale), glbRect);
if ((glbRect.SizeX() == 0) || (glbRect.SizeY() == 0))
continue;
m_threadDrawer->screen()->setClipRect(areas[i]);
m_threadDrawer->screen()->enableClipRect(true);
m_threadDrawer->screen()->beginFrame();
m_currentRenderCommand->m_renderFn(
m_currentRenderCommand->m_paintEvent,
m_currentRenderCommand->m_frameScreen,
glbRect,
glbRect,
scaleLevel,
false);
/// all unprocessed commands should be cancelled
if (m_currentRenderCommand->m_paintEvent->isCancelled() && m_glQueue)
m_glQueue->cancelCommands();
if (!m_renderState->m_isEmptyModelCurrent)
cumulativeEmptyModelCurrent = m_renderState->m_isEmptyModelCurrent;
m_threadDrawer->screen()->endFrame();
if (IsCancelled())
break;
}
}
if (IsCancelled())
break;
/// if something were actually drawn, or (exclusive or) we are repainting the whole rect
if (!cumulativeEmptyModelCurrent || fullRectRepaint)
{
m2::PointD centerPt = m_currentRenderCommand->m_frameScreen.GlobalRect().GetGlobalRect().Center();
string countryName = m_countryNameFn(centerPt);
m_renderState->m_countryNameActual = countryName;
m_renderState->m_isEmptyModelActual = cumulativeEmptyModelCurrent && !countryName.empty();
}
/// setting the "whole texture" clip rect to render texts opened by panning.
m_threadDrawer->screen()->setClipRect(textureRect);
m_threadDrawer->beginFrame();
m_threadDrawer->screen()->overlay()->draw(m_threadDrawer->screen().get(), math::Identity<double, 3>());
m_threadDrawer->endFrame();
}
double duration = timer.ElapsedSeconds();
if (!IsCancelled())
{
{
threads::ConditionGuard g1(m_hasRenderCommands);
{
threads::MutexGuard g2(*m_renderState->m_mutex.get());
m_renderState->m_duration = duration;
}
m_currentRenderCommand.reset();
if (m_renderCommands.empty())
g1.Signal();
}
invalidate();
signalBenchmarkFence();
}
}
// By VNG: We can't destroy render context in drawing thread.
// Notify render context instead.
if (!m_glQueue)
m_renderContext->endThreadDrawing();
}
void RenderQueueRoutine::addWindowHandle(shared_ptr<WindowHandle> window)
{
m_windowHandles.push_back(window);
}
void RenderQueueRoutine::Invalidate::perform()
{
if (isDebugging())
LOG(LDEBUG, ("performing Invalidate command"));
for_each(m_windowHandles.begin(),
m_windowHandles.end(),
bind(&WindowHandle::invalidate, _1));
}
void RenderQueueRoutine::Invalidate::cancel()
{
perform();
}
void RenderQueueRoutine::invalidate()
{
for_each(m_windowHandles.begin(),
m_windowHandles.end(),
bind(&WindowHandle::invalidate, _1));
if (m_glQueue)
{
shared_ptr<Invalidate> command(new Invalidate());
command->m_windowHandles = m_windowHandles;
m_glQueue->processPacket(yg::gl::Packet(command, yg::gl::Packet::EFramePoint));
}
}
void RenderQueueRoutine::addCommand(render_fn_t const & fn, ScreenBase const & frameScreen)
{
/// Command queue modification is syncronized by mutex
threads::ConditionGuard guard(m_hasRenderCommands);
bool needToSignal = m_renderCommands.empty();
/// Clearing a list of commands.
m_renderCommands.clear();
/// pushing back new RenderCommand.
m_renderCommands.push_back(make_shared_ptr(new RenderModelCommand(frameScreen, fn)));
/// if we are in benchmarking mode, we shouldn't cancel any render command
/// else, if we are not panning, we should cancel the render command in progress to start a new one
if ((m_currentRenderCommand != 0)
&& (!IsPanningAndRotate(m_currentRenderCommand->m_frameScreen, frameScreen)))
m_currentRenderCommand->m_paintEvent->cancel();
if (needToSignal)
guard.Signal();
}
void RenderQueueRoutine::initializeGL(shared_ptr<yg::gl::RenderContext> const & renderContext,
shared_ptr<yg::ResourceManager> const & resourceManager)
{
m_frameBuffer.reset();
m_frameBuffer.reset(new yg::gl::FrameBuffer());
m_auxFrameBuffer.reset();
m_auxFrameBuffer.reset(new yg::gl::FrameBuffer());
m_renderContext = renderContext;
m_resourceManager = resourceManager;
}
void RenderQueueRoutine::memoryWarning()
{
m_threadDrawer->screen()->memoryWarning();
}
void RenderQueueRoutine::enterBackground()
{
m_threadDrawer->screen()->enterBackground();
}
void RenderQueueRoutine::enterForeground()
{
m_threadDrawer->screen()->enterForeground();
}
void RenderQueueRoutine::waitForEmptyAndFinished()
{
/// Command queue modification is syncronized by mutex
threads::ConditionGuard guard(m_hasRenderCommands);
if (!m_renderCommands.empty() || (m_currentRenderCommand != 0))
guard.Wait();
}
void RenderQueueRoutine::setGLQueue(yg::gl::PacketsQueue * glQueue)
{
m_glQueue = glQueue;
}
int RenderQueueRoutine::insertBenchmarkFence()
{
m_currentFenceID = m_fenceManager.insertFence();
return m_currentFenceID;
}
void RenderQueueRoutine::joinBenchmarkFence(int id)
{
CHECK(m_currentFenceID == id, ());
m_fenceManager.joinFence(id);
}
void RenderQueueRoutine::signalBenchmarkFence()
{
if (m_currentFenceID != -1)
m_fenceManager.signalFence(m_currentFenceID);
}

156
map/render_queue_routine.hpp
View file

@ -1,156 +0,0 @@
#pragma once
#include "../base/thread.hpp"
#include "../base/condition.hpp"
#include "../base/commands_queue.hpp"
#include "../base/fence_manager.hpp"
#include "../geometry/rect2d.hpp"
#include "../geometry/screenbase.hpp"
#include "../std/list.hpp"
#include "../std/function.hpp"
#include "../yg/color.hpp"
class DrawerYG;
namespace threads
{
class Condition;
}
class PaintEvent;
class WindowHandle;
namespace yg
{
class ResourceManager;
namespace gl
{
class RenderContext;
class FrameBuffer;
class RenderBuffer;
class BaseTexture;
class RenderState;
class Screen;
class PacketsQueue;
}
}
class RenderQueueRoutine : public threads::IRoutine
{
public:
typedef function<void(shared_ptr<PaintEvent>, ScreenBase const &, m2::RectD const &, m2::RectD const &, int, bool)> render_fn_t;
typedef function<string (m2::PointD const &)> TCountryNameFn;
private:
struct RenderModelCommand
{
ScreenBase m_frameScreen;
shared_ptr<PaintEvent> m_paintEvent;
render_fn_t m_renderFn;
RenderModelCommand(ScreenBase const & frameScreen,
render_fn_t renderFn);
};
struct Invalidate : public yg::gl::Command
{
list<shared_ptr<WindowHandle> > m_windowHandles;
void perform();
void cancel();
};
shared_ptr<yg::gl::RenderContext> m_renderContext;
shared_ptr<yg::gl::FrameBuffer> m_frameBuffer;
shared_ptr<yg::gl::FrameBuffer> m_auxFrameBuffer;
shared_ptr<DrawerYG> m_threadDrawer;
shared_ptr<yg::gl::Screen> m_auxScreen;
shared_ptr<yg::gl::RenderBuffer> m_newDepthBuffer;
shared_ptr<yg::gl::BaseTexture> m_newActualTarget;
shared_ptr<yg::gl::BaseTexture> m_newBackBuffer;
threads::Condition m_hasRenderCommands;
threads::Condition * m_glCondition;
shared_ptr<RenderModelCommand> m_currentRenderCommand;
list<shared_ptr<RenderModelCommand> > m_renderCommands;
list<shared_ptr<RenderModelCommand> > m_benchmarkRenderCommands;
shared_ptr<yg::gl::RenderState> m_renderState;
shared_ptr<yg::ResourceManager> m_resourceManager;
/// A list of window handles to notify about ending rendering operations.
list<shared_ptr<WindowHandle> > m_windowHandles;
FenceManager m_fenceManager;
int m_currentFenceID;
bool m_isMultiSampled;
bool m_doPeriodicalUpdate;
double m_updateInterval;
double m_visualScale;
string m_skinName;
bool m_isBenchmarking;
unsigned m_scaleEtalonSize;
yg::Color m_bgColor;
yg::gl::PacketsQueue * m_glQueue;
TCountryNameFn m_countryNameFn;
void waitForRenderCommand(list<shared_ptr<RenderModelCommand> > & cmdList,
threads::ConditionGuard & guard);
public:
RenderQueueRoutine(shared_ptr<yg::gl::RenderState> const & renderState,
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking,
unsigned scaleEtalonSize,
double visualScale,
yg::Color const & bgColor);
/// initialize GL rendering
/// this function is called just before the thread starts.
void initializeGL(shared_ptr<yg::gl::RenderContext> const & renderContext,
shared_ptr<yg::ResourceManager> const & resourceManager);
/// This function should always be called from the main thread.
void Cancel();
void onSize(int w, int h);
void SetCountryNameFn(TCountryNameFn countryNameFn);
/// Check, whether the resize command is queued, and resize accordingly.
void processResize(ScreenBase const & frameScreen);
/// Get update areas for the current render state
bool getUpdateAreas(ScreenBase const & oldScreen, m2::RectI const & oldRect,
ScreenBase const & newScreen, m2::RectI const & newRect,
vector<m2::RectI> & areas);
/// Thread procedure
void Do();
/// invalidate all connected window handles
void invalidate();
/// add monitoring window
void addWindowHandle(shared_ptr<WindowHandle> window);
/// add model rendering command to rendering queue
void addCommand(render_fn_t const & fn, ScreenBase const & frameScreen);
/// set the resolution scale factor to the main thread drawer;
void setVisualScale(double visualScale);
/// free all available memory
void memoryWarning();
/// free all easily recreatable opengl resources and make sure that no opengl call will be made.
void enterBackground();
/// recreate all necessary opengl resources and prepare to run in foreground.
void enterForeground();
/// wait for all commands are processed.
void waitForEmptyAndFinished();
void setGLQueue(yg::gl::PacketsQueue * glQueue);
int insertBenchmarkFence();
void signalBenchmarkFence();
void joinBenchmarkFence(int id);
};

5
yg/blitter.cpp
View file

@ -329,12 +329,7 @@ namespace yg
Vertex::setupLayout(blitStorage.m_vertices->glPtr());
if (m_texture)
{
#ifndef USING_GLSL
OGLCHECK(glEnable(GL_TEXTURE_2D));
#endif
m_texture->makeCurrent();
}
unsigned short idxData[4] = {0, 1, 2, 3};
memcpy(blitStorage.m_indices->data(), idxData, sizeof(idxData));

12
yg/geometry_renderer.cpp
View file

@ -364,10 +364,6 @@ namespace yg
OGLCHECK(glActiveTexture(GL_TEXTURE0));
#ifndef USING_GLSL
OGLCHECK(glEnableFn(GL_TEXTURE_2D));
#endif
OGLCHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
OGLCHECK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
@ -389,9 +385,6 @@ namespace yg
OGLCHECK(glBlendFunc(GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA));
#ifndef USING_GLSL
OGLCHECK(glColor4f(1.0f, 1.0f, 1.0f, 1.0f));
#endif
}
void GeometryRenderer::ApplyStates::cancel()
@ -415,10 +408,6 @@ namespace yg
if (isDebugging())
LOG(LINFO, ("performing ApplyBlitStates command"));
#ifndef USING_GLSL
OGLCHECK(glEnable(GL_TEXTURE_2D));
#endif
OGLCHECK(glDisableFn(GL_ALPHA_TEST_MWM));
OGLCHECK(glDisableFn(GL_BLEND));
OGLCHECK(glDisableFn(GL_DEPTH_TEST));
@ -439,6 +428,5 @@ namespace yg
else
processCommand(command);
}
}
}

21
yg/internal/opengl.hpp
View file

@ -4,9 +4,6 @@
#include "../../base/logging.hpp"
// This define is set in yg.pro
// #define USING_GLSL
#if defined(OMIM_OS_WINDOWS)
#include "../../std/windows.hpp"
#include <gl/gl.h>
@ -22,15 +19,9 @@
#include <TargetConditionals.h>
#ifdef OMIM_OS_IPHONE
#ifdef USING_GLSL
#define USE_OPENGLES20_IF_AVAILABLE 1
#include <OpenGLES/ES2/gl.h>
#define OMIM_GL_ES
#else
#define USE_OPENGLES20_IF_AVAILABLE 0
#include <OpenGLES/ES1/gl.h>
#define OMIM_GL_ES
#endif
#define USE_OPENGLES20_IF_AVAILABLE 1
#include <OpenGLES/ES2/gl.h>
#define OMIM_GL_ES
#else
#include <OpenGL/gl.h>
#include <OpenGL/glext.h>
@ -38,11 +29,7 @@
#elif defined(OMIM_OS_ANDROID)
#ifdef USING_GLSL
#include <GLES2/gl2.h>
#else
#include <GLES/gl.h>
#endif
#include <GLES2/gl2.h>
#define OMIM_GL_ES

13
yg/symbol_element.cpp
View file

@ -78,8 +78,6 @@ namespace yg
m2::PointD posPt = tieRect(m2::RectD(texRect), m);
#ifdef USING_GLSL
posPt -= pivot();
r->drawStraightTexturedPolygon(pivot(),
@ -87,17 +85,6 @@ namespace yg
posPt.x, posPt.y, posPt.x + texRect.SizeX(), posPt.y + texRect.SizeY(),
yg::maxDepth - 2,
style->m_pipelineID);
#else
r->drawTexturedPolygon(m2::PointD(0.0, 0.0), 0.0,
texRect.minX(), texRect.minY(), texRect.maxX(), texRect.maxY(),
posPt.x, posPt.y, posPt.x + texRect.SizeX(), posPt.y + texRect.SizeY(),
yg::maxDepth - 2,
style->m_pipelineID);
#endif
}
int SymbolElement::visualRank() const

7
yg/text_element.cpp
View file

@ -114,7 +114,6 @@ namespace yg
if (doTransformPivotOnly)
{
#ifdef USING_GLSL
m2::PointD offsPt = offs + elem.m_pt;
m2::PointD fullPt = pv + offs + elem.m_pt;
@ -122,12 +121,6 @@ namespace yg
offsPt.y -= fullPt.y - floor(fullPt.y);
screen->drawStraightGlyph(pv, offsPt, glyphStyle, depth);
#else
glyphPt = pv + offs + elem.m_pt;
glyphAngle = elem.m_angle;
screen->drawGlyph(glyphPt, m2::PointD(0.0, 0.0), glyphAngle, 0, glyphStyle, depth);
#endif
}
else
{

24
yg/yg.pro
View file

@ -120,28 +120,16 @@ HEADERS += \
display_list.hpp \
data_traits.hpp
CONFIG += glsl
win32* {
SOURCES += internal/opengl_win32.cpp
} else: android*|iphone* {
CONFIG(glsl) {
DEFINES += USING_GLSL
HEADERS += internal/opengl_glsl_impl.hpp
SOURCES += internal/opengl_glsl_es2.cpp \
internal/opengl_glsl_impl.cpp
} else {
SOURCES += internal/opengl_es.cpp
}
HEADERS += internal/opengl_glsl_impl.hpp
SOURCES += internal/opengl_glsl_es2.cpp \
internal/opengl_glsl_impl.cpp
} else {
CONFIG(glsl) {
DEFINES += USING_GLSL
HEADERS += internal/opengl_glsl_impl.hpp
SOURCES += internal/opengl_glsl_ext.cpp \
internal/opengl_glsl_impl.cpp
} else {
SOURCES += internal/opengl_ext.cpp
}
HEADERS += internal/opengl_glsl_impl.hpp
SOURCES += internal/opengl_glsl_ext.cpp \
internal/opengl_glsl_impl.cpp
}