From 9225cde271cbcbff05a3b04f25a35d015c1aaa56 Mon Sep 17 00:00:00 2001 From: rachytski Date: Fri, 11 Nov 2011 12:15:36 +0400 Subject: [PATCH] refactored RenderPolicy initialization and OpenGL resource allocation. greatly simplifies initialization code. --- iphone/Maps/Classes/EAGLView.h | 27 ++--- iphone/Maps/Classes/EAGLView.mm | 135 +++++++--------------- iphone/Maps/Classes/MapViewController.mm | 7 +- iphone/Maps/Classes/RenderBuffer.hpp | 2 +- iphone/Maps/Classes/RenderBuffer.mm | 2 +- map/benchmark_framework.cpp | 17 +-- map/benchmark_framework.hpp | 3 +- map/benchmark_render_policy_mt.cpp | 13 +-- map/benchmark_render_policy_mt.hpp | 8 +- map/benchmark_tiling_render_policy_mt.cpp | 13 +-- map/benchmark_tiling_render_policy_mt.hpp | 8 +- map/coverage_generator.cpp | 35 +++--- map/coverage_generator.hpp | 7 +- map/framework.cpp | 123 ++++++++++---------- map/framework.hpp | 23 ++-- map/framework_factory.cpp | 6 +- map/framework_factory.hpp | 2 +- map/partial_render_policy.cpp | 17 +-- map/partial_render_policy.hpp | 8 +- map/render_policy.cpp | 97 +++++++++++----- map/render_policy.hpp | 47 +++++--- map/render_policy_mt.cpp | 114 +++++++++++++----- map/render_policy_mt.hpp | 14 ++- map/render_policy_st.cpp | 61 ++++++++-- map/render_policy_st.hpp | 12 +- map/tile_renderer.cpp | 15 +-- map/tile_renderer.hpp | 11 +- map/tiling_render_policy_mt.cpp | 107 ++++++++++++----- map/tiling_render_policy_mt.hpp | 17 +-- map/tiling_render_policy_st.cpp | 107 ++++++++++++----- map/tiling_render_policy_st.hpp | 21 +++- qt/draw_widget.cpp | 119 ++++++++++--------- qt/draw_widget.hpp | 22 ++-- qt/widgets.hpp | 3 + yg/geometry_batcher.cpp | 8 +- 35 files changed, 692 insertions(+), 539 deletions(-) diff --git a/iphone/Maps/Classes/EAGLView.h b/iphone/Maps/Classes/EAGLView.h index d459d23751..517c9551fc 100644 --- a/iphone/Maps/Classes/EAGLView.h +++ b/iphone/Maps/Classes/EAGLView.h @@ -1,20 +1,15 @@ #import #import -#import -#import #import #import "MapViewController.h" #include "../../std/shared_ptr.hpp" -#include "../../map/drawer_yg.hpp" #include "../../map/framework.hpp" #include "../../map/feature_vec_model.hpp" -#include "../../platform/video_timer.hpp" #include"RenderBuffer.hpp" namespace iphone { - class WindowHandle; class RenderContext; class RenderBuffer; } @@ -34,27 +29,21 @@ typedef Framework framework_t; // Note that setting the view non-opaque will only work if the EAGL surface has an alpha channel. @interface EAGLView : UIView { -@private - // The pixel dimensions of the backbuffer - - shared_ptr renderContext; - shared_ptr frameBuffer; - @public - shared_ptr windowHandle; - shared_ptr videoTimer; - shared_ptr drawer; + framework_t * framework; + shared_ptr renderContext; + shared_ptr frameBuffer; shared_ptr renderBuffer; + RenderPolicy * renderPolicy; } -- (void) drawFrame; +- (void) initRenderPolicy; + @property (nonatomic, assign) framework_t * framework; -@property (nonatomic, assign) shared_ptr windowHandle; -@property (nonatomic, assign) shared_ptr videoTimer; -@property (nonatomic, assign) shared_ptr drawer; @property (nonatomic, assign) shared_ptr renderContext; @property (nonatomic, assign) shared_ptr renderBuffer; -@property (nonatomic, assign) shared_ptr resourceManager; +@property (nonatomic, assign) shared_ptr frameBuffer; +@property (nonatomic, assign) RenderPolicy * renderPolicy; @end diff --git a/iphone/Maps/Classes/EAGLView.mm b/iphone/Maps/Classes/EAGLView.mm index f746180695..73ca18b726 100644 --- a/iphone/Maps/Classes/EAGLView.mm +++ b/iphone/Maps/Classes/EAGLView.mm @@ -8,19 +8,19 @@ #include "../../yg/resource_manager.hpp" #include "../../yg/internal/opengl.hpp" #include "../../yg/skin.hpp" +#include "../../map/render_policy.hpp" #include "../../platform/platform.hpp" +#include "../../platform/video_timer.hpp" #include "RenderBuffer.hpp" #include "RenderContext.hpp" @implementation EAGLView @synthesize framework; -@synthesize windowHandle; -@synthesize videoTimer; -@synthesize drawer; +@synthesize frameBuffer; @synthesize renderContext; @synthesize renderBuffer; -@synthesize resourceManager; +@synthesize renderPolicy; // You must implement this method + (Class)layerClass @@ -47,11 +47,6 @@ } renderContext->makeCurrent(); - - // to avoid grid bug on 3G device - yg::RtFormat fmt = yg::Rt4Bpp; - if ([[NSString stringWithFormat:@"%s", glGetString(GL_RENDERER)] hasPrefix:@"PowerVR MBX"]) - fmt = yg::Rt8Bpp; /// ColorFormat : RGB565 /// Backbuffer : YES, (to prevent from loosing content when mixing with ordinary layers). @@ -77,100 +72,55 @@ if (scrW == 640) self.contentScaleFactor = 2.0; } - - frameBuffer = shared_ptr(new yg::gl::FrameBuffer()); - - int bigVBSize = pow(2, ceil(log2(15000 * sizeof(yg::gl::Vertex)))); - int bigIBSize = pow(2, ceil(log2(30000 * sizeof(unsigned short)))); - - int smallVBSize = pow(2, ceil(log2(1500 * sizeof(yg::gl::Vertex)))); - int smallIBSize = pow(2, ceil(log2(3000 * sizeof(unsigned short)))); - - int blitVBSize = pow(2, ceil(log2(10 * sizeof(yg::gl::AuxVertex)))); - int blitIBSize = pow(2, ceil(log2(10 * sizeof(unsigned short)))); - - int multiBlitVBSize = pow(2, ceil(log2(300 * sizeof(yg::gl::AuxVertex)))); - int multiBlitIBSize = pow(2, ceil(log2(300 * sizeof(unsigned short)))); - - int tinyVBSize = pow(2, ceil(log2(300 * sizeof(yg::gl::AuxVertex)))); - int tinyIBSize = pow(2, ceil(log2(300 * sizeof(unsigned short)))); - - NSLog(@"Vendor: %s, Renderer: %s", glGetString(GL_VENDOR), glGetString(GL_RENDERER)); - - Platform & pl = GetPlatform(); - - size_t dynTexWidth = 512; - size_t dynTexHeight = 256; - size_t dynTexCount = 10; - - size_t fontTexWidth = 512; - size_t fontTexHeight = 256; - size_t fontTexCount = 5; - - resourceManager = shared_ptr(new yg::ResourceManager( - bigVBSize, bigIBSize, 6 * GetPlatform().CpuCores(), - smallVBSize, smallIBSize, 15 * GetPlatform().CpuCores(), - blitVBSize, blitIBSize, 15 * GetPlatform().CpuCores(), - dynTexWidth, dynTexHeight, dynTexCount * GetPlatform().CpuCores(), - fontTexWidth, fontTexHeight, fontTexCount * GetPlatform().CpuCores(), - "unicode_blocks.txt", - "fonts_whitelist.txt", - "fonts_blacklist.txt", - 2 * 1024 * 1024, - GetPlatform().CpuCores() + 2, - fmt, - !yg::gl::g_isBufferObjectsSupported)); - - resourceManager->initMultiBlitStorage(multiBlitVBSize, multiBlitIBSize, 10); - resourceManager->initTinyStorage(tinyVBSize, tinyIBSize, 10); - - Platform::FilesList fonts; - pl.GetFontNames(fonts); - resourceManager->addFonts(fonts); - - DrawerYG::params_t p; - p.m_resourceManager = resourceManager; - p.m_frameBuffer = frameBuffer; - p.m_glyphCacheID = resourceManager->guiThreadGlyphCacheID(); - p.m_skinName = pl.SkinName(); - p.m_visualScale = pl.VisualScale(); - p.m_isSynchronized = false; - p.m_useTinyStorage = true; //< use tiny buffers to minimize CPU->GPU data transfer overhead. - - drawer = shared_ptr(new DrawerYG(p)); - - windowHandle.reset(new WindowHandle()); - - windowHandle->setUpdatesEnabled(false); - - typedef void (*drawFrameFn)(id, SEL); - SEL drawFrameSel = @selector(drawFrame); - drawFrameFn drawFrameImpl = (drawFrameFn)[self methodForSelector:drawFrameSel]; - - videoTimer.reset(CreateIOSVideoTimer(bind(drawFrameImpl, self, drawFrameSel))); - - windowHandle->setVideoTimer(videoTimer); - - windowHandle->setRenderContext(renderContext); } - + return self; } +- (void)initRenderPolicy +{ + frameBuffer = shared_ptr(new yg::gl::FrameBuffer()); + + NSLog(@"Vendor: %s, Renderer: %s", glGetString(GL_VENDOR), glGetString(GL_RENDERER)); + + // to avoid grid bug on 3G device + yg::RtFormat fmt = yg::Rt4Bpp; + if ([[NSString stringWithFormat:@"%s", glGetString(GL_RENDERER)] hasPrefix:@"PowerVR MBX"]) + fmt = yg::Rt8Bpp; + + DrawerYG::params_t p; + p.m_frameBuffer = frameBuffer; + + typedef void (*drawFrameFn)(id, SEL); + SEL drawFrameSel = @selector(drawFrame); + drawFrameFn drawFrameImpl = (drawFrameFn)[self methodForSelector:drawFrameSel]; + + VideoTimer * videoTimer = CreateIOSVideoTimer(bind(drawFrameImpl, self, drawFrameSel)); + + renderPolicy = CreateRenderPolicy(videoTimer, p, renderContext); + + framework->SetRenderPolicy(renderPolicy); +} + - (void)onSize:(int)width withHeight:(int)height { - framework->OnSize(width, height); /// free old video memory frameBuffer->resetRenderTarget(); + frameBuffer->resetDepthBuffer(); renderBuffer.reset(); /// allocate the new one renderBuffer = shared_ptr(new iphone::RenderBuffer(renderContext, (CAEAGLLayer*)self.layer)); frameBuffer->setRenderTarget(renderBuffer); frameBuffer->setDepthBuffer(make_shared_ptr(new yg::gl::RenderBuffer(width, height, true))); - frameBuffer->onSize(width, height); - drawer->onSize(width, height); + framework->OnSize(width, height); + +/* frameBuffer->onSize(width, height); + drawer->onSize(width, height);*/ + + shared_ptr drawer = framework->GetRenderPolicy()->GetDrawer(); + drawer->screen()->beginFrame(); drawer->screen()->clear(); drawer->screen()->endFrame(); @@ -178,10 +128,13 @@ - (void)drawFrame { + shared_ptr drawer = framework->GetRenderPolicy()->GetDrawer(); + shared_ptr pe(new PaintEvent(drawer.get())); - if (windowHandle->needRedraw()) + + if (framework->NeedRedraw()) { - windowHandle->setNeedRedraw(false); + framework->SetNeedRedraw(false); framework->BeginPaint(pe); framework->DoPaint(pe); renderBuffer->present(); @@ -198,7 +151,7 @@ - (void)dealloc { - videoTimer.reset(); + // m_framework->SetRenderPolicy(0); [EAGLContext setCurrentContext:nil]; [super dealloc]; } diff --git a/iphone/Maps/Classes/MapViewController.mm b/iphone/Maps/Classes/MapViewController.mm index 0fd095894f..906e84a8d3 100644 --- a/iphone/Maps/Classes/MapViewController.mm +++ b/iphone/Maps/Classes/MapViewController.mm @@ -118,11 +118,8 @@ framework_t * m_framework = NULL; // cyclic dependence, @TODO refactor. // Here we're creating view and window handle in it, and later we should pass framework to the view EAGLView * v = (EAGLView *)self.view; - - shared_ptr windowHandle = [(EAGLView*)self.view windowHandle]; - shared_ptr resourceManager = [(EAGLView*)self.view resourceManager]; - m_framework = FrameworkFactory::CreateFramework(windowHandle, 40); + m_framework = FrameworkFactory::CreateFramework(); v.framework = m_framework; m_StickyThreshold = 10; @@ -135,7 +132,7 @@ framework_t * m_framework = NULL; if (!res) m_framework->SetMaxWorldRect(); - m_framework->InitializeGL([(EAGLView*)self.view renderContext], resourceManager); + [v initRenderPolicy]; m_framework->Invalidate(); } diff --git a/iphone/Maps/Classes/RenderBuffer.hpp b/iphone/Maps/Classes/RenderBuffer.hpp index 187fb3a488..50281fd02e 100644 --- a/iphone/Maps/Classes/RenderBuffer.hpp +++ b/iphone/Maps/Classes/RenderBuffer.hpp @@ -24,7 +24,7 @@ namespace iphone void makeCurrent(); - unsigned int id(); + unsigned int id() const; void present(); diff --git a/iphone/Maps/Classes/RenderBuffer.mm b/iphone/Maps/Classes/RenderBuffer.mm index ba7e69d0f8..cefe0434dc 100644 --- a/iphone/Maps/Classes/RenderBuffer.mm +++ b/iphone/Maps/Classes/RenderBuffer.mm @@ -29,7 +29,7 @@ namespace iphone OGLCHECK(glDeleteRenderbuffersOES(1, &m_id)); } - unsigned int RenderBuffer::id() + unsigned int RenderBuffer::id() const { return m_id; } diff --git a/map/benchmark_framework.cpp b/map/benchmark_framework.cpp index a1857d3903..dcb32c97ba 100644 --- a/map/benchmark_framework.cpp +++ b/map/benchmark_framework.cpp @@ -12,10 +12,6 @@ #include "../version/version.hpp" -#include "benchmark_tiling_render_policy_mt.hpp" -#include "benchmark_render_policy_mt.hpp" -#include "render_policy_st.hpp" - template class DoGetBenchmarks { set m_processed; @@ -139,21 +135,12 @@ void BenchmarkFramework::ReAddLocalMaps() } template -BenchmarkFramework::BenchmarkFramework(shared_ptr const & wh, - size_t bottomShift) - : base_type(wh, bottomShift), - m_paintDuration(0), +BenchmarkFramework::BenchmarkFramework() + : m_paintDuration(0), m_maxDuration(0), m_isBenchmarkFinished(false), m_isBenchmarkInitialized(false) { - bool isBenchmarkingMT = false; - Settings::Get("IsBenchmarkingMT", isBenchmarkingMT); - - if (isBenchmarkingMT) - base_type::SetRenderPolicy(make_shared_ptr(new BenchmarkTilingRenderPolicyMT(wh, bind(&base_type::DrawModel, this, _1, _2, _3, _4, _5, true)))); - else - base_type::SetRenderPolicy(make_shared_ptr(new BenchmarkRenderPolicyMT(wh, bind(&base_type::DrawModel, this, _1, _2, _3, _4, _5, false)))); m_startTime = my::FormatCurrentTime(); diff --git a/map/benchmark_framework.hpp b/map/benchmark_framework.hpp index 1a5239dc94..2d874d74dc 100644 --- a/map/benchmark_framework.hpp +++ b/map/benchmark_framework.hpp @@ -65,8 +65,7 @@ private: public: - BenchmarkFramework(shared_ptr const & wh, - size_t bottomShift); + BenchmarkFramework(); void OnSize(int w, int h); diff --git a/map/benchmark_render_policy_mt.cpp b/map/benchmark_render_policy_mt.cpp index ddb1efc9da..3317b6db57 100644 --- a/map/benchmark_render_policy_mt.cpp +++ b/map/benchmark_render_policy_mt.cpp @@ -4,17 +4,12 @@ #include "../base/logging.hpp" -BenchmarkRenderPolicyMT::BenchmarkRenderPolicyMT(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicyMT(wh, renderFn) +BenchmarkRenderPolicyMT::BenchmarkRenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicyMT(videoTimer, params, primaryRC) {} -void BenchmarkRenderPolicyMT::Initialize(shared_ptr const & rc, - shared_ptr const & rm) -{ - RenderPolicyMT::Initialize(rc, rm); -} - void BenchmarkRenderPolicyMT::DrawFrame(shared_ptr const & e, ScreenBase const & s) { diff --git a/map/benchmark_render_policy_mt.hpp b/map/benchmark_render_policy_mt.hpp index 9e2a7266ce..ecb2c0b790 100644 --- a/map/benchmark_render_policy_mt.hpp +++ b/map/benchmark_render_policy_mt.hpp @@ -5,11 +5,9 @@ class BenchmarkRenderPolicyMT : public RenderPolicyMT { public: - BenchmarkRenderPolicyMT(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & rc, - shared_ptr const & rm); + BenchmarkRenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void DrawFrame(shared_ptr const & e, ScreenBase const & s); }; diff --git a/map/benchmark_tiling_render_policy_mt.cpp b/map/benchmark_tiling_render_policy_mt.cpp index c1f09827ac..682daaf87f 100644 --- a/map/benchmark_tiling_render_policy_mt.cpp +++ b/map/benchmark_tiling_render_policy_mt.cpp @@ -2,17 +2,12 @@ #include "benchmark_tiling_render_policy_mt.hpp" BenchmarkTilingRenderPolicyMT::BenchmarkTilingRenderPolicyMT( - shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn) - : TilingRenderPolicyMT(wh, renderFn) + VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : TilingRenderPolicyMT(videoTimer, params, primaryRC) {} -void BenchmarkTilingRenderPolicyMT::Initialize(shared_ptr const & renderContext, - shared_ptr const & resourceManager) -{ - TilingRenderPolicyMT::Initialize(renderContext, resourceManager); -} - void BenchmarkTilingRenderPolicyMT::DrawFrame(shared_ptr const & e, ScreenBase const & s) { diff --git a/map/benchmark_tiling_render_policy_mt.hpp b/map/benchmark_tiling_render_policy_mt.hpp index 396c72dc33..cba5f09734 100644 --- a/map/benchmark_tiling_render_policy_mt.hpp +++ b/map/benchmark_tiling_render_policy_mt.hpp @@ -6,11 +6,9 @@ class BenchmarkTilingRenderPolicyMT : public TilingRenderPolicyMT { public: - BenchmarkTilingRenderPolicyMT(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & renderContext, - shared_ptr const & resourceManager); + BenchmarkTilingRenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void DrawFrame(shared_ptr const & e, ScreenBase const & s); }; diff --git a/map/coverage_generator.cpp b/map/coverage_generator.cpp index b319ec9adb..652b8ae3f4 100644 --- a/map/coverage_generator.cpp +++ b/map/coverage_generator.cpp @@ -14,7 +14,9 @@ CoverageGenerator::CoverageGenerator( size_t tileSize, size_t scaleEtalonSize, TileRenderer * tileRenderer, - shared_ptr const & windowHandle) + shared_ptr const & windowHandle, + shared_ptr const & primaryRC, + shared_ptr const & rm) : m_queue(1), m_tileRenderer(tileRenderer), m_workCoverage(0), @@ -22,6 +24,19 @@ CoverageGenerator::CoverageGenerator( m_sequenceID(0), m_windowHandle(windowHandle) { + m_resourceManager = rm; + m_renderContext = primaryRC->createShared(); + + m_currentStylesCache.reset(new yg::StylesCache(rm, + rm->cacheThreadGlyphCacheID())); + + m_workStylesCache.reset(new yg::StylesCache(rm, + rm->cacheThreadGlyphCacheID())); + + m_queue.AddInitCommand(bind(&CoverageGenerator::InitializeThreadGL, this)); + m_queue.AddFinCommand(bind(&CoverageGenerator::FinalizeThreadGL, this)); + + m_queue.Start(); } void CoverageGenerator::InitializeThreadGL() @@ -34,24 +49,6 @@ void CoverageGenerator::FinalizeThreadGL() m_renderContext->endThreadDrawing(); } -void CoverageGenerator::Initialize(shared_ptr const & rc, - shared_ptr const & rm) -{ - m_resourceManager = rm; - m_renderContext = rc->createShared(); - - m_currentStylesCache.reset(new yg::StylesCache(rm, - rm->cacheThreadGlyphCacheID())); - - m_workStylesCache.reset(new yg::StylesCache(rm, - rm->cacheThreadGlyphCacheID())); - - m_queue.AddInitCommand(bind(&CoverageGenerator::InitializeThreadGL, this)); - m_queue.AddFinCommand(bind(&CoverageGenerator::FinalizeThreadGL, this)); - - m_queue.Start(); -} - CoverageGenerator::~CoverageGenerator() { delete m_workCoverage; diff --git a/map/coverage_generator.hpp b/map/coverage_generator.hpp index 5cb487ea2f..2c83be0a7c 100644 --- a/map/coverage_generator.hpp +++ b/map/coverage_generator.hpp @@ -50,7 +50,9 @@ public: CoverageGenerator(size_t tileSize, size_t scaleEtalonSize, TileRenderer * tileRenderer, - shared_ptr const & windowHandle); + shared_ptr const & windowHandle, + shared_ptr const & primaryRC, + shared_ptr const & rm); ~CoverageGenerator(); @@ -65,9 +67,6 @@ public: void Cancel(); - void Initialize(shared_ptr const & rc, - shared_ptr const & rm); - void WaitForEmptyAndFinished(); ScreenCoverage & CurrentCoverage(); diff --git a/map/framework.cpp b/map/framework.cpp index f6e2983fe6..e3a96010a5 100644 --- a/map/framework.cpp +++ b/map/framework.cpp @@ -3,10 +3,6 @@ #include "drawer_yg.hpp" #include "feature_vec_model.hpp" #include "benchmark_provider.hpp" -#include "render_policy_st.hpp" -#include "render_policy_mt.hpp" -#include "tiling_render_policy_st.hpp" -#include "tiling_render_policy_mt.hpp" #include "../defines.hpp" @@ -31,20 +27,8 @@ #include "../std/fstream.hpp" #include "../std/target_os.hpp" -#include "render_policy_st.hpp" -#include "render_policy_mt.hpp" - -#include "tiling_render_policy_st.hpp" -#include "tiling_render_policy_mt.hpp" - -#include "partial_render_policy.hpp" - using namespace feature; -template -Framework::~Framework() -{} - template void Framework::AddMap(string const & file) { @@ -100,9 +84,8 @@ void Framework::OnCompassUpdate(location::CompassInfo const & info) } template -Framework::Framework(shared_ptr windowHandle, - size_t bottomShift) - : m_windowHandle(windowHandle), +Framework::Framework() + : m_hasPendingInvalidate(false), m_metresMinWidth(20), m_metresMaxWidth(1000000), #if defined(OMIM_OS_MAC) || defined(OMIM_OS_WINDOWS) || defined(OMIM_OS_LINUX) @@ -110,21 +93,11 @@ Framework::Framework(shared_ptr windowHandle, #else m_minRulerWidth(60), #endif + m_width(0), + m_height(0), m_centeringMode(EDoNothing) // m_tileSize(GetPlatform().TileSize()) { - // on Android policy is created in AndroidFramework -#ifndef OMIM_OS_ANDROID - -// SetRenderPolicy(make_shared_ptr(new RenderPolicyST(windowHandle, bind(&this_type::DrawModel, this, _1, _2, _3, _4, _5, false)))); -// SetRenderPolicy(make_shared_ptr(new TilingRenderPolicyMT(windowHandle, bind(&this_type::DrawModel, this, _1, _2, _3, _4, _5, true)))); - SetRenderPolicy(make_shared_ptr(new RenderPolicyMT(windowHandle, bind(&this_type::DrawModel, this, _1, _2, _3, _4, _5, false)))); -// SetRenderPolicy(make_shared_ptr(new PartialRenderPolicy(windowHandle, bind(&this_type::DrawModel, this, _1, _2, _3, _4, _5, false)))); - -#endif - - m_informationDisplay.setBottomShift(bottomShift); - #ifdef DRAW_TOUCH_POINTS m_informationDisplay.enableDebugPoints(true); #endif @@ -141,11 +114,6 @@ Framework::Framework(shared_ptr windowHandle, m_informationDisplay.enableDebugInfo(true); #endif - bool isVisualLogEnabled = false; - Settings::Get("VisualLog", isVisualLogEnabled); - m_informationDisplay.enableLog(isVisualLogEnabled, m_windowHandle.get()); - m_informationDisplay.setVisualScale(visScale); - m_model.InitClassificator(); // initializes model with locally downloaded maps @@ -173,6 +141,10 @@ Framework::Framework(shared_ptr windowHandle, languages::SaveSettings(langCodes); } +template +Framework::~Framework() +{} + template void Framework::GetLocalMaps(vector & outMaps) { @@ -202,15 +174,6 @@ void Framework::GetLocalMaps(vector & outMaps) outMaps.push_back(dataFiles[i]); } -template -void Framework::InitializeGL( - shared_ptr const & primaryContext, - shared_ptr const & resourceManager) -{ - yg::gl::RenderContext::initParams(); - m_renderPolicy->Initialize(primaryContext, resourceManager); -} - template TModel & Framework::get_model() { @@ -244,19 +207,22 @@ void Framework::SetMaxWorldRect() template bool Framework::NeedRedraw() const { - return m_windowHandle->needRedraw() || m_renderPolicy->NeedRedraw(); + return m_renderPolicy->NeedRedraw(); } template void Framework::SetNeedRedraw(bool flag) { - m_windowHandle->setNeedRedraw(false); + m_renderPolicy->GetWindowHandle()->setNeedRedraw(false); } template void Framework::Invalidate() { - m_windowHandle->invalidate(); + if (m_renderPolicy) + m_renderPolicy->GetWindowHandle()->invalidate(); + else + m_hasPendingInvalidate = true; } template @@ -282,21 +248,27 @@ void Framework::OnSize(int w, int h) if (w < 2) w = 2; if (h < 2) h = 2; - m_informationDisplay.setDisplayRect(m2::RectI(m2::PointI(0, 0), m2::PointU(w, h))); + if (m_renderPolicy) + { + m_informationDisplay.setDisplayRect(m2::RectI(m2::PointI(0, 0), m2::PointU(w, h))); - m2::RectI const & viewPort = m_renderPolicy->OnSize(w, h); + m2::RectI const & viewPort = m_renderPolicy->OnSize(w, h); - m_navigator.OnSize( - viewPort.minX(), - viewPort.minY(), - viewPort.SizeX(), - viewPort.SizeY()); + m_navigator.OnSize( + viewPort.minX(), + viewPort.minY(), + viewPort.SizeX(), + viewPort.SizeY()); + } + + m_width = w; + m_height = h; } template bool Framework::SetUpdatesEnabled(bool doEnable) { - return m_windowHandle->setUpdatesEnabled(doEnable); + return m_renderPolicy->GetWindowHandle()->setUpdatesEnabled(doEnable); } template @@ -312,21 +284,26 @@ double Framework::GetCurrentScale() const return scales::GetScaleLevelD(glbRect); } +template +RenderPolicy::TRenderFn Framework::DrawModelFn() +{ + return bind(&Framework::DrawModel, this, _1, _2, _3, _4, _5); +} + /// Actual rendering function. template void Framework::DrawModel(shared_ptr const & e, ScreenBase const & screen, m2::RectD const & selectRect, m2::RectD const & clipRect, - int scaleLevel, - bool isTiling) + int scaleLevel) { fwork::DrawProcessor doDraw(clipRect, screen, e, scaleLevel); try { //threads::MutexGuard lock(m_modelSyn); - if (isTiling) + if (m_renderPolicy->IsTiling()) m_model.ForEachFeature_TileDrawing(selectRect, doDraw, scaleLevel); else m_model.ForEachFeature(selectRect, doDraw, scaleLevel); @@ -689,10 +666,34 @@ void Framework::Search(string const & text, SearchCallbackT callback) } template -void Framework::SetRenderPolicy(shared_ptr const & renderPolicy) +void Framework::SetRenderPolicy(RenderPolicy * renderPolicy) { - m_renderPolicy = renderPolicy; + bool isVisualLogEnabled = false; + Settings::Get("VisualLog", isVisualLogEnabled); + m_informationDisplay.enableLog(isVisualLogEnabled, renderPolicy->GetWindowHandle().get()); + m_informationDisplay.setVisualScale(GetPlatform().VisualScale()); + + yg::gl::RenderContext::initParams(); + m_renderPolicy.reset(renderPolicy); + + m_renderPolicy->SetRenderFn(DrawModelFn()); + m_navigator.SetSupportRotation(m_renderPolicy->DoSupportRotation()); + + if ((m_width != 0) && (m_height != 0)) + OnSize(m_width, m_height); + + if (m_hasPendingInvalidate) + { + m_renderPolicy->GetWindowHandle()->invalidate(); + m_hasPendingInvalidate = false; + } +} + +template +RenderPolicy * Framework::GetRenderPolicy() const +{ + return m_renderPolicy.get(); } template diff --git a/map/framework.hpp b/map/framework.hpp index 02fc439cbe..6ba5ae1193 100644 --- a/map/framework.hpp +++ b/map/framework.hpp @@ -69,8 +69,8 @@ protected: model_t m_model; Navigator m_navigator; - shared_ptr m_windowHandle; - shared_ptr m_renderPolicy; + scoped_ptr m_renderPolicy; + bool m_hasPendingInvalidate; InformationDisplay m_informationDisplay; @@ -78,6 +78,9 @@ protected: double const m_metresMaxWidth; int const m_minRulerWidth; + int m_width; + int m_height; + enum TGpsCenteringMode { EDoNothing, @@ -102,7 +105,8 @@ protected: void GetLocalMaps(vector & outMaps); public: - Framework(shared_ptr windowHandle, size_t bottomShift); + + Framework(); virtual ~Framework(); storage::Storage & Storage() { return m_storage; } @@ -111,10 +115,8 @@ public: void OnGpsUpdate(location::GpsInfo const & info); void OnCompassUpdate(location::CompassInfo const & info); - void SetRenderPolicy(shared_ptr const & rp); - - void InitializeGL(shared_ptr const & primaryContext, - shared_ptr const & resourceManager); + void SetRenderPolicy(RenderPolicy * renderPolicy); + RenderPolicy * GetRenderPolicy() const; model_t & get_model(); @@ -125,16 +127,15 @@ public: void PrepareToShutdown(); -public: - void SetupMeasurementSystem(); + RenderPolicy::TRenderFn DrawModelFn(); + void DrawModel(shared_ptr const & e, ScreenBase const & screen, m2::RectD const & selectRect, m2::RectD const & clipRect, - int scaleLevel, - bool isTiling); + int scaleLevel); void Search(string const & text, SearchCallbackT callback); search::Engine * GetSearchEngine(); diff --git a/map/framework_factory.cpp b/map/framework_factory.cpp index 6c336b519b..4ff3312f30 100644 --- a/map/framework_factory.cpp +++ b/map/framework_factory.cpp @@ -7,15 +7,15 @@ #include "../platform/settings.hpp" template -Framework * FrameworkFactory::CreateFramework(shared_ptr const & wh, size_t bottomShift) +Framework * FrameworkFactory::CreateFramework() { bool benchmarkingEnabled = false; (void)Settings::Get("IsBenchmarking", benchmarkingEnabled); if (benchmarkingEnabled) - return new BenchmarkFramework(wh, bottomShift); + return new BenchmarkFramework(); else - return new Framework(wh, bottomShift); + return new Framework(); } template class FrameworkFactory; diff --git a/map/framework_factory.hpp b/map/framework_factory.hpp index 8446b51f44..6c78002abd 100644 --- a/map/framework_factory.hpp +++ b/map/framework_factory.hpp @@ -9,5 +9,5 @@ template class FrameworkFactory { public: - static Framework * CreateFramework(shared_ptr const & wh, size_t bottomShift); + static Framework * CreateFramework(); }; diff --git a/map/partial_render_policy.cpp b/map/partial_render_policy.cpp index 6dfff10e2e..fc5aafadd4 100644 --- a/map/partial_render_policy.cpp +++ b/map/partial_render_policy.cpp @@ -5,18 +5,13 @@ #include "../yg/internal/opengl.hpp" #include "../std/bind.hpp" -PartialRenderPolicy::PartialRenderPolicy(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicyMT(wh, renderFn) +PartialRenderPolicy::PartialRenderPolicy(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicyMT(videoTimer, params, primaryRC) { SetNeedSynchronize(true); -} - -void PartialRenderPolicy::Initialize(shared_ptr const & rc, - shared_ptr const & rm) -{ - m_renderQueue.SetGLQueue(&m_glQueue, &m_glCondition); - RenderPolicyMT::Initialize(rc, rm); + m_renderQueue->SetGLQueue(&m_glQueue, &m_glCondition); } void PartialRenderPolicy::ProcessRenderQueue(list & renderQueue) @@ -106,5 +101,5 @@ void PartialRenderPolicy::EndFrame(shared_ptr const & paintEvent, bool PartialRenderPolicy::NeedRedraw() const { - return !m_glQueue.Empty(); + return RenderPolicyMT::NeedRedraw() || !m_glQueue.Empty(); } diff --git a/map/partial_render_policy.hpp b/map/partial_render_policy.hpp index a0cb2e94f6..72f8c17b57 100644 --- a/map/partial_render_policy.hpp +++ b/map/partial_render_policy.hpp @@ -23,11 +23,9 @@ private: public: - PartialRenderPolicy(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & rc, - shared_ptr const & rm); + PartialRenderPolicy(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void DrawFrame(shared_ptr const & paintEvent, ScreenBase const & screenBase); diff --git a/map/render_policy.cpp b/map/render_policy.cpp index bbe776eb56..54c65a0a0e 100644 --- a/map/render_policy.cpp +++ b/map/render_policy.cpp @@ -1,48 +1,30 @@ #include "../base/SRC_FIRST.hpp" #include "render_policy.hpp" -#include "window_handle.hpp" + +#include "../map/render_policy_st.hpp" +#include "../map/render_policy_mt.hpp" +#include "../map/tiling_render_policy_st.hpp" +#include "../map/tiling_render_policy_mt.hpp" +#include "../map/partial_render_policy.hpp" +#include "../map/benchmark_render_policy_mt.hpp" +#include "../map/benchmark_tiling_render_policy_mt.hpp" + +#include "../platform/video_timer.hpp" +#include "../platform/settings.hpp" RenderPolicy::~RenderPolicy() {} -RenderPolicy::RenderPolicy(shared_ptr const & windowHandle, - TRenderFn const & renderFn, - bool doSupportRotation) +RenderPolicy::RenderPolicy(shared_ptr const & primaryRC, bool doSupportRotation) : m_bgColor(0xEE, 0xEE, 0xDD, 0xFF), - m_windowHandle(windowHandle), - m_renderFn(renderFn), + m_primaryRC(primaryRC), m_doSupportRotation(doSupportRotation) {} -yg::Color const & RenderPolicy::bgColor() const -{ - return m_bgColor; -} - -shared_ptr const & RenderPolicy::resourceManager() const -{ - return m_resourceManager; -} - -shared_ptr const & RenderPolicy::windowHandle() const -{ - return m_windowHandle; -} - -RenderPolicy::TRenderFn RenderPolicy::renderFn() const -{ - return m_renderFn; -} - -void RenderPolicy::Initialize(shared_ptr const &, - shared_ptr const & resourceManager) -{ - m_resourceManager = resourceManager; -} - m2::RectI const RenderPolicy::OnSize(int w, int h) { + m_drawer->onSize(w, h); return m2::RectI(0, 0, w, h); } @@ -103,6 +85,57 @@ bool RenderPolicy::DoSupportRotation() const } bool RenderPolicy::NeedRedraw() const +{ + return m_windowHandle->needRedraw(); +} + +bool RenderPolicy::IsTiling() const { return false; } + +shared_ptr const & RenderPolicy::GetDrawer() const +{ + return m_drawer; +} + +shared_ptr const & RenderPolicy::GetWindowHandle() const +{ + return m_windowHandle; +} + +void RenderPolicy::SetRenderFn(TRenderFn renderFn) +{ + m_renderFn = renderFn; +} + +RenderPolicy * CreateRenderPolicy(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) +{ + bool benchmarkingEnabled = false; + Settings::Get("IsBenchmarking", benchmarkingEnabled); + + if (benchmarkingEnabled) + { + bool isBenchmarkingMT = false; + Settings::Get("IsBenchmarkingMT", isBenchmarkingMT); + + if (isBenchmarkingMT) + return new BenchmarkTilingRenderPolicyMT(videoTimer, params, primaryRC); + else + return new BenchmarkRenderPolicyMT(videoTimer, params, primaryRC); + } + else + { +#ifdef OMIM_OS_ANDROID + return new PartialRenderPolicy(videoTimer, params, primaryRC); +#endif +#ifdef OMIM_OS_IPHONE + return new RenderPolicyMT(videoTimer, params, primaryRC); +#endif +#ifdef OMIM_OS_DESKTOP + return new RenderPolicyMT(videoTimer, params, primaryRC); +#endif + } +} diff --git a/map/render_policy.hpp b/map/render_policy.hpp index 51b6736f76..989e346910 100644 --- a/map/render_policy.hpp +++ b/map/render_policy.hpp @@ -1,5 +1,7 @@ #pragma once +#include "drawer_yg.hpp" + #include "../yg/color.hpp" #include "../std/function.hpp" @@ -9,6 +11,7 @@ class PaintEvent; class ScreenBase; +class VideoTimer; namespace yg { @@ -26,27 +29,26 @@ class RenderPolicy { public: - typedef function, ScreenBase const &, m2::RectD const &, m2::RectD const &, int)> TRenderFn; - -private: - - yg::Color m_bgColor; - shared_ptr m_resourceManager; - shared_ptr m_windowHandle; - TRenderFn m_renderFn; - bool m_doSupportRotation; + typedef function, + ScreenBase const &, + m2::RectD const &, + m2::RectD const &, + int)> TRenderFn; protected: - yg::Color const & bgColor() const; - shared_ptr const & resourceManager() const; - shared_ptr const & windowHandle() const; - TRenderFn renderFn() const; + yg::Color m_bgColor; + shared_ptr m_resourceManager; + shared_ptr m_primaryRC; + shared_ptr m_windowHandle; + shared_ptr m_drawer; + TRenderFn m_renderFn; + bool m_doSupportRotation; public: /// constructor - RenderPolicy(shared_ptr const & windowHandle, TRenderFn const & renderFn, bool doSupportRotation); + RenderPolicy(shared_ptr const & primaryRC, bool doSupportRotation); /// destructor virtual ~RenderPolicy(); /// starting frame @@ -57,10 +59,6 @@ public: virtual void EndFrame(shared_ptr const & e, ScreenBase const & s); /// processing resize request virtual m2::RectI const OnSize(int w, int h); - /// initialize render policy - virtual void Initialize(shared_ptr const & primaryContext, - shared_ptr const & resourceManager) = 0; - /// reacting on navigation actions /// @{ virtual void StartDrag(); @@ -76,7 +74,20 @@ public: virtual void StopRotate(double a, double timeInSec); /// @} + /// the start point of rendering in renderpolicy. + virtual void SetRenderFn(TRenderFn renderFn); + bool DoSupportRotation() const; + bool IsTiling() const; bool NeedRedraw() const; + + shared_ptr const & GetDrawer() const; + shared_ptr const & GetWindowHandle() const; + }; + +RenderPolicy * CreateRenderPolicy(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); + diff --git a/map/render_policy_mt.cpp b/map/render_policy_mt.cpp index 9c347203cb..810adfedb6 100644 --- a/map/render_policy_mt.cpp +++ b/map/render_policy_mt.cpp @@ -3,7 +3,9 @@ #include "render_policy_mt.hpp" #include "events.hpp" #include "drawer_yg.hpp" +#include "window_handle.hpp" #include "../yg/render_state.hpp" +#include "../yg/internal/opengl.hpp" #include "../geometry/transformations.hpp" @@ -11,21 +13,76 @@ #include "../platform/platform.hpp" -RenderPolicyMT::RenderPolicyMT(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicy(wh, renderFn, false), - m_renderQueue(GetPlatform().SkinName(), - false, - true, - 0.1, - false, - GetPlatform().ScaleEtalonSize(), - GetPlatform().VisualScale(), - bgColor()), +RenderPolicyMT::RenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicy(primaryRC, false), m_DoAddCommand(true), m_DoSynchronize(true) { - m_renderQueue.AddWindowHandle(wh); + m_resourceManager = make_shared_ptr(new yg::ResourceManager( + 50000 * sizeof(yg::gl::Vertex), + 100000 * sizeof(unsigned short), + 15, + 5000 * sizeof(yg::gl::Vertex), + 10000 * sizeof(unsigned short), + 100, + 10 * sizeof(yg::gl::AuxVertex), + 10 * sizeof(unsigned short), + 50, + 512, 256, + 10, + 512, 256, + 5, + "unicode_blocks.txt", + "fonts_whitelist.txt", + "fonts_blacklist.txt", + 2 * 1024 * 1024, + GetPlatform().CpuCores() + 2, + yg::Rt8Bpp, + !yg::gl::g_isBufferObjectsSupported)); + + m_resourceManager->initTinyStorage(300 * sizeof(yg::gl::Vertex), 600 * sizeof(unsigned short), 20); + + Platform::FilesList fonts; + GetPlatform().GetFontNames(fonts); + m_resourceManager->addFonts(fonts); + + DrawerYG::params_t p = params; + + p.m_resourceManager = m_resourceManager; + p.m_dynamicPagesCount = 2; + p.m_textPagesCount = 2; + p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID(); + p.m_skinName = GetPlatform().SkinName(); + p.m_visualScale = GetPlatform().VisualScale(); + p.m_isSynchronized = true; + p.m_useTinyStorage = true; + + m_drawer.reset(new DrawerYG(p)); + + m_windowHandle.reset(new WindowHandle()); + + m_windowHandle->setUpdatesEnabled(false); + m_windowHandle->setVideoTimer(make_shared_ptr(videoTimer)); + m_windowHandle->setRenderContext(primaryRC); + + m_renderQueue.reset(new RenderQueue(GetPlatform().SkinName(), + false, + true, + 0.1, + false, + GetPlatform().ScaleEtalonSize(), + GetPlatform().VisualScale(), + m_bgColor)); + + m_renderQueue->AddWindowHandle(m_windowHandle); +} + +void RenderPolicyMT::SetRenderFn(TRenderFn renderFn) +{ + RenderPolicy::SetRenderFn(renderFn); + m_renderQueue->initializeGL(m_primaryRC, m_resourceManager); } void RenderPolicyMT::SetNeedSynchronize(bool flag) @@ -33,18 +90,13 @@ void RenderPolicyMT::SetNeedSynchronize(bool flag) m_DoSynchronize = flag; } -void RenderPolicyMT::Initialize(shared_ptr const & rc, - shared_ptr const & rm) -{ - m_renderQueue.initializeGL(rc, rm); - RenderPolicy::Initialize(rc, rm); -} - m2::RectI const RenderPolicyMT::OnSize(int w, int h) { - m_renderQueue.OnSize(w, h); + RenderPolicy::OnSize(w, h); - m2::PointU pt = m_renderQueue.renderState().coordSystemShift(); + 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); } @@ -58,30 +110,30 @@ void RenderPolicyMT::EndFrame(shared_ptr const & e, ScreenBase const & s) { if (m_DoSynchronize) - m_renderQueue.renderState().m_mutex->Unlock(); + m_renderQueue->renderState().m_mutex->Unlock(); } void RenderPolicyMT::DrawFrame(shared_ptr const & e, ScreenBase const & s) { - if (m_DoAddCommand && (s != m_renderQueue.renderState().m_actualScreen)) - m_renderQueue.AddCommand(renderFn(), s); + if (m_DoAddCommand && (s != m_renderQueue->renderState().m_actualScreen)) + m_renderQueue->AddCommand(m_renderFn, s); DrawerYG * pDrawer = e->drawer(); - e->drawer()->screen()->clear(bgColor()); + e->drawer()->screen()->clear(m_bgColor); if (m_DoSynchronize) - m_renderQueue.renderState().m_mutex->Lock(); + m_renderQueue->renderState().m_mutex->Lock(); - if (m_renderQueue.renderState().m_actualTarget.get() != 0) + if (m_renderQueue->renderState().m_actualTarget.get() != 0) { - m2::PointD const ptShift = m_renderQueue.renderState().coordSystemShift(false); + m2::PointD const ptShift = m_renderQueue->renderState().coordSystemShift(false); - math::Matrix m = m_renderQueue.renderState().m_actualScreen.PtoGMatrix() * s.GtoPMatrix(); + math::Matrix m = m_renderQueue->renderState().m_actualScreen.PtoGMatrix() * s.GtoPMatrix(); m = math::Shift(m, -ptShift); - pDrawer->screen()->blit(m_renderQueue.renderState().m_actualTarget, m); + pDrawer->screen()->blit(m_renderQueue->renderState().m_actualTarget, m); } } @@ -111,5 +163,5 @@ void RenderPolicyMT::StopScale() RenderQueue & RenderPolicyMT::GetRenderQueue() { - return m_renderQueue; + return *m_renderQueue.get(); } diff --git a/map/render_policy_mt.hpp b/map/render_policy_mt.hpp index 515434405f..78a03fc2db 100644 --- a/map/render_policy_mt.hpp +++ b/map/render_policy_mt.hpp @@ -2,24 +2,27 @@ #include "render_policy.hpp" #include "render_queue.hpp" +#include "drawer_yg.hpp" + #include "../geometry/point2d.hpp" +#include "../std/scoped_ptr.hpp" class WindowHandle; +class VideoTimer; class RenderPolicyMT : public RenderPolicy { protected: - RenderQueue m_renderQueue; + scoped_ptr m_renderQueue; bool m_DoAddCommand; bool m_DoSynchronize; public: - RenderPolicyMT(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn); - void Initialize(shared_ptr const & rc, - shared_ptr const & rm); + RenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void BeginFrame(shared_ptr const & e, ScreenBase const & s); @@ -41,4 +44,5 @@ public: RenderQueue & GetRenderQueue(); void SetNeedSynchronize(bool flag); + void SetRenderFn(TRenderFn renderFn); }; diff --git a/map/render_policy_st.cpp b/map/render_policy_st.cpp index 919c49d991..f18adbd20c 100644 --- a/map/render_policy_st.cpp +++ b/map/render_policy_st.cpp @@ -3,22 +3,63 @@ #include "render_policy_st.hpp" #include "events.hpp" #include "drawer_yg.hpp" +#include "window_handle.hpp" #include "../yg/info_layer.hpp" +#include "../yg/internal/opengl.hpp" #include "../indexer/scales.hpp" #include "../geometry/screenbase.hpp" #include "../platform/platform.hpp" -RenderPolicyST::RenderPolicyST(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicy(wh, renderFn, false) -{} - -void RenderPolicyST::Initialize(shared_ptr const & rc, - shared_ptr const & rm) +RenderPolicyST::RenderPolicyST(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicy(primaryRC, false) { - RenderPolicy::Initialize(rc, rm); + m_resourceManager = make_shared_ptr(new yg::ResourceManager( + 50000 * sizeof(yg::gl::Vertex), + 100000 * sizeof(unsigned short), + 15, + 5000 * sizeof(yg::gl::Vertex), + 10000 * sizeof(unsigned short), + 100, + 10 * sizeof(yg::gl::AuxVertex), + 10 * sizeof(unsigned short), + 50, + 512, 256, + 10, + 512, 256, + 5, + "unicode_blocks.txt", + "fonts_whitelist.txt", + "fonts_blacklist.txt", + 2 * 1024 * 1024, + 1, + yg::Rt8Bpp, + !yg::gl::g_isBufferObjectsSupported)); + + Platform::FilesList fonts; + GetPlatform().GetFontNames(fonts); + m_resourceManager->addFonts(fonts); + + DrawerYG::params_t p = params; + + p.m_resourceManager = m_resourceManager; + p.m_dynamicPagesCount = 2; + p.m_textPagesCount = 2; + p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID(); + p.m_skinName = GetPlatform().SkinName(); + p.m_visualScale = GetPlatform().VisualScale(); + p.m_isSynchronized = true; + + m_drawer.reset(new DrawerYG(p)); + + m_windowHandle.reset(new WindowHandle()); + + m_windowHandle->setUpdatesEnabled(false); + m_windowHandle->setVideoTimer(make_shared_ptr(videoTimer)); + m_windowHandle->setRenderContext(primaryRC); } void RenderPolicyST::DrawFrame(shared_ptr const & e, @@ -36,9 +77,9 @@ void RenderPolicyST::DrawFrame(shared_ptr const & e, e->drawer()->screen()->setInfoLayer(infoLayer); - e->drawer()->screen()->clear(bgColor()); + e->drawer()->screen()->clear(m_bgColor); - renderFn()(e, s, s.ClipRect(), s.ClipRect(), scales::GetScaleLevel(glbRect)); + m_renderFn(e, s, s.ClipRect(), s.ClipRect(), scales::GetScaleLevel(glbRect)); infoLayer->draw(e->drawer()->screen().get(), math::Identity()); e->drawer()->screen()->resetInfoLayer(); diff --git a/map/render_policy_st.hpp b/map/render_policy_st.hpp index 87a2fbc122..b26288fb07 100644 --- a/map/render_policy_st.hpp +++ b/map/render_policy_st.hpp @@ -1,18 +1,16 @@ #pragma once #include "render_policy.hpp" +#include "drawer_yg.hpp" -class WindowHandle; +class VideoTimer; class RenderPolicyST : public RenderPolicy { -private: public: - RenderPolicyST(shared_ptr const & wh, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & rc, - shared_ptr const & rm); + RenderPolicyST(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void DrawFrame(shared_ptr const & paintEvent, ScreenBase const & screenBase); diff --git a/map/tile_renderer.cpp b/map/tile_renderer.cpp index 282819417d..b492edc137 100644 --- a/map/tile_renderer.cpp +++ b/map/tile_renderer.cpp @@ -17,7 +17,10 @@ TileRenderer::TileRenderer( unsigned maxTilesCount, unsigned executorsCount, yg::Color const & bgColor, - RenderPolicy::TRenderFn const & renderFn + RenderPolicy::TRenderFn const & renderFn, + shared_ptr const & primaryRC, + shared_ptr const & rm, + double visualScale ) : m_queue(executorsCount), m_tileCache(maxTilesCount - executorsCount - 1), m_renderFn(renderFn), @@ -25,14 +28,8 @@ TileRenderer::TileRenderer( m_bgColor(bgColor), m_sequenceID(0) { -} - -void TileRenderer::Initialize(shared_ptr const & primaryContext, - shared_ptr const & resourceManager, - double visualScale) -{ - m_resourceManager = resourceManager; - m_primaryContext = primaryContext; + m_resourceManager = rm; + m_primaryContext = primaryRC; m_threadData.resize(m_queue.ExecutorsCount()); diff --git a/map/tile_renderer.hpp b/map/tile_renderer.hpp index c6dd1f8f5a..47c9161249 100644 --- a/map/tile_renderer.hpp +++ b/map/tile_renderer.hpp @@ -70,13 +70,12 @@ public: unsigned maxTilesCount, unsigned tasksCount, yg::Color const & bgColor, - RenderPolicy::TRenderFn const & renderFn); + RenderPolicy::TRenderFn const & renderFn, + shared_ptr const & primaryRC, + shared_ptr const & rm, + double visualScale); /// destructor. - ~TileRenderer(); - /// set the primary context. it starts the rendering thread. - void Initialize(shared_ptr const & primaryContext, - shared_ptr const & resourceManager, - double visualScale); + virtual ~TileRenderer(); /// add command to the commands queue. void AddCommand(Tiler::RectInfo const & rectInfo, int sequenceID, diff --git a/map/tiling_render_policy_mt.cpp b/map/tiling_render_policy_mt.cpp index 2307c86079..140e6e9a3c 100644 --- a/map/tiling_render_policy_mt.cpp +++ b/map/tiling_render_policy_mt.cpp @@ -14,32 +14,82 @@ #include "window_handle.hpp" #include "screen_coverage.hpp" -TilingRenderPolicyMT::TilingRenderPolicyMT(shared_ptr const & windowHandle, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicy(windowHandle, renderFn, true), - m_tileRenderer(GetPlatform().SkinName(), - GetPlatform().MaxTilesCount(), - 1, //GetPlatform().CpuCores(), - bgColor(), - renderFn), - m_coverageGenerator(GetPlatform().TileSize(), - GetPlatform().ScaleEtalonSize(), - &m_tileRenderer, - windowHandle) +TilingRenderPolicyMT::TilingRenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicy(primaryRC, true) { + m_resourceManager = make_shared_ptr(new yg::ResourceManager( + 50000 * sizeof(yg::gl::Vertex), + 100000 * sizeof(unsigned short), + 15, + 5000 * sizeof(yg::gl::Vertex), + 10000 * sizeof(unsigned short), + 100, + 10 * sizeof(yg::gl::AuxVertex), + 10 * sizeof(unsigned short), + 50, + 512, 256, + 10, + 512, 256, + 5, + "unicode_blocks.txt", + "fonts_whitelist.txt", + "fonts_blacklist.txt", + 2 * 1024 * 1024, + GetPlatform().CpuCores() + 2, + yg::Rt8Bpp, + !yg::gl::g_isBufferObjectsSupported)); + m_resourceManager->initMultiBlitStorage(500 * sizeof(yg::gl::AuxVertex), 500 * sizeof(unsigned short), 10); + m_resourceManager->initRenderTargets(GetPlatform().TileSize(), GetPlatform().TileSize(), GetPlatform().MaxTilesCount()); + m_resourceManager->initStyleCacheTextures(m_resourceManager->fontTextureWidth(), m_resourceManager->fontTextureHeight() * 2, 2); + m_resourceManager->initTinyStorage(300 * sizeof(yg::gl::Vertex), 600 * sizeof(unsigned short), 50); + + Platform::FilesList fonts; + GetPlatform().GetFontNames(fonts); + m_resourceManager->addFonts(fonts); + + DrawerYG::params_t p = params; + + p.m_resourceManager = m_resourceManager; + p.m_dynamicPagesCount = 2; + p.m_textPagesCount = 2; + p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID(); + p.m_skinName = GetPlatform().SkinName(); + p.m_visualScale = GetPlatform().VisualScale(); + p.m_useTinyStorage = true; + p.m_isSynchronized = false; + + m_drawer.reset(new DrawerYG(p)); + + m_windowHandle.reset(new WindowHandle()); + + m_windowHandle->setUpdatesEnabled(false); + m_windowHandle->setVideoTimer(make_shared_ptr(videoTimer)); + m_windowHandle->setRenderContext(primaryRC); } -void TilingRenderPolicyMT::Initialize(shared_ptr const & primaryContext, - shared_ptr const & resourceManager) +void TilingRenderPolicyMT::SetRenderFn(TRenderFn renderFn) { - RenderPolicy::Initialize(primaryContext, resourceManager); + RenderPolicy::SetRenderFn(renderFn); - resourceManager->initRenderTargets(GetPlatform().TileSize(), GetPlatform().TileSize(), GetPlatform().MaxTilesCount()); - resourceManager->initStyleCacheTextures(resourceManager->fontTextureWidth(), resourceManager->fontTextureHeight() * 2, 2); + m_tileRenderer.reset(new TileRenderer(GetPlatform().SkinName(), + GetPlatform().MaxTilesCount(), + 1, //GetPlatform().CpuCores(), + m_bgColor, + renderFn, + m_primaryRC, + m_resourceManager, + GetPlatform().VisualScale())); - m_tileRenderer.Initialize(primaryContext, resourceManager, GetPlatform().VisualScale()); - m_coverageGenerator.Initialize(primaryContext, resourceManager); + m_coverageGenerator.reset(new CoverageGenerator(GetPlatform().TileSize(), + GetPlatform().ScaleEtalonSize(), + m_tileRenderer.get(), + m_windowHandle, + m_primaryRC, + m_resourceManager + )); } void TilingRenderPolicyMT::BeginFrame(shared_ptr const & e, ScreenBase const & s) @@ -48,29 +98,29 @@ void TilingRenderPolicyMT::BeginFrame(shared_ptr const & e, ScreenBa void TilingRenderPolicyMT::EndFrame(shared_ptr const & e, ScreenBase const & s) { - ScreenCoverage * curCvg = &m_coverageGenerator.CurrentCoverage(); + ScreenCoverage * curCvg = &m_coverageGenerator->CurrentCoverage(); curCvg->EndFrame(e->drawer()->screen().get()); - m_coverageGenerator.Mutex().Unlock(); + m_coverageGenerator->Mutex().Unlock(); } void TilingRenderPolicyMT::DrawFrame(shared_ptr const & e, ScreenBase const & currentScreen) { DrawerYG * pDrawer = e->drawer(); - pDrawer->screen()->clear(bgColor()); + pDrawer->screen()->clear(m_bgColor); - m_coverageGenerator.AddCoverScreenTask(currentScreen); + m_coverageGenerator->AddCoverScreenTask(currentScreen); - m_coverageGenerator.Mutex().Lock(); + m_coverageGenerator->Mutex().Lock(); - ScreenCoverage * curCvg = &m_coverageGenerator.CurrentCoverage(); + ScreenCoverage * curCvg = &m_coverageGenerator->CurrentCoverage(); curCvg->Draw(pDrawer->screen().get(), currentScreen); } TileRenderer & TilingRenderPolicyMT::GetTileRenderer() { - return m_tileRenderer; + return *m_tileRenderer.get(); } void TilingRenderPolicyMT::StartScale() @@ -82,3 +132,8 @@ void TilingRenderPolicyMT::StopScale() { m_isScaling = false; } + +bool TilingRenderPolicyMT::IsTiling() const +{ + return true; +} diff --git a/map/tiling_render_policy_mt.hpp b/map/tiling_render_policy_mt.hpp index c0bb0da4ce..8d8c11d185 100644 --- a/map/tiling_render_policy_mt.hpp +++ b/map/tiling_render_policy_mt.hpp @@ -7,6 +7,7 @@ #include "screen_coverage.hpp" #include "../yg/info_layer.hpp" +#include "../std/scoped_ptr.hpp" namespace yg { @@ -23,9 +24,9 @@ class TilingRenderPolicyMT : public RenderPolicy { private: - TileRenderer m_tileRenderer; + scoped_ptr m_tileRenderer; - CoverageGenerator m_coverageGenerator; + scoped_ptr m_coverageGenerator; ScreenBase m_currentScreen; @@ -39,11 +40,9 @@ protected: public: - TilingRenderPolicyMT(shared_ptr const & windowHandle, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & renderContext, - shared_ptr const & resourceManager); + TilingRenderPolicyMT(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void BeginFrame(shared_ptr const & ev, ScreenBase const & s); void DrawFrame(shared_ptr const & ev, ScreenBase const & s); @@ -51,4 +50,8 @@ public: virtual void StartScale(); virtual void StopScale(); + + bool IsTiling() const; + + void SetRenderFn(TRenderFn renderFn); }; diff --git a/map/tiling_render_policy_st.cpp b/map/tiling_render_policy_st.cpp index 0d39975fa4..678bb46d46 100644 --- a/map/tiling_render_policy_st.cpp +++ b/map/tiling_render_policy_st.cpp @@ -10,43 +10,83 @@ #include "../yg/renderbuffer.hpp" #include "../yg/resource_manager.hpp" #include "../yg/base_texture.hpp" +#include "../yg/internal/opengl.hpp" #include "../platform/platform.hpp" - -TilingRenderPolicyST::TilingRenderPolicyST(shared_ptr const & windowHandle, - RenderPolicy::TRenderFn const & renderFn) - : RenderPolicy(windowHandle, renderFn, false), +TilingRenderPolicyST::TilingRenderPolicyST(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC) + : RenderPolicy(primaryRC, true), m_tileCache(GetPlatform().MaxTilesCount() - 1), m_tiler(GetPlatform().TileSize(), GetPlatform().ScaleEtalonSize()) -{} - -void TilingRenderPolicyST::Initialize(shared_ptr const & primaryContext, - shared_ptr const & rm) { - RenderPolicy::Initialize(primaryContext, rm); + m_resourceManager = make_shared_ptr(new yg::ResourceManager( + 50000 * sizeof(yg::gl::Vertex), + 100000 * sizeof(unsigned short), + 15, + 5000 * sizeof(yg::gl::Vertex), + 10000 * sizeof(unsigned short), + 100, + 10 * sizeof(yg::gl::AuxVertex), + 10 * sizeof(unsigned short), + 50, + 512, 256, + 10, + 512, 256, + 5, + "unicode_blocks.txt", + "fonts_whitelist.txt", + "fonts_blacklist.txt", + 2 * 1024 * 1024, + GetPlatform().CpuCores() + 2, + yg::Rt8Bpp, + !yg::gl::g_isBufferObjectsSupported)); - rm->initRenderTargets(GetPlatform().TileSize(), GetPlatform().TileSize(), GetPlatform().MaxTilesCount()); + m_resourceManager->initMultiBlitStorage(500 * sizeof(yg::gl::AuxVertex), 500 * sizeof(unsigned short), 10); + m_resourceManager->initRenderTargets(GetPlatform().TileSize(), GetPlatform().TileSize(), GetPlatform().MaxTilesCount()); + + Platform::FilesList fonts; + GetPlatform().GetFontNames(fonts); + m_resourceManager->addFonts(fonts); + + DrawerYG::params_t p = params; + + p.m_resourceManager = m_resourceManager; + p.m_dynamicPagesCount = 2; + p.m_textPagesCount = 2; + p.m_glyphCacheID = m_resourceManager->guiThreadGlyphCacheID(); + p.m_skinName = GetPlatform().SkinName(); + p.m_visualScale = GetPlatform().VisualScale(); + p.m_isSynchronized = true; + + m_drawer.reset(new DrawerYG(p)); + + m_windowHandle.reset(new WindowHandle()); + + m_windowHandle->setUpdatesEnabled(false); + m_windowHandle->setVideoTimer(make_shared_ptr(videoTimer)); + m_windowHandle->setRenderContext(primaryRC); /// render single tile on the same thread shared_ptr frameBuffer(new yg::gl::FrameBuffer()); - unsigned tileWidth = resourceManager()->tileTextureWidth(); - unsigned tileHeight = resourceManager()->tileTextureHeight(); + unsigned tileWidth = m_resourceManager->tileTextureWidth(); + unsigned tileHeight = m_resourceManager->tileTextureHeight(); shared_ptr depthBuffer(new yg::gl::RenderBuffer(tileWidth, tileHeight, true)); frameBuffer->setDepthBuffer(depthBuffer); - DrawerYG::params_t params; + p = DrawerYG::Params(); - params.m_resourceManager = resourceManager(); - params.m_frameBuffer = frameBuffer; - params.m_glyphCacheID = resourceManager()->guiThreadGlyphCacheID(); - params.m_threadID = 0; - params.m_skinName = GetPlatform().SkinName(); - params.m_visualScale = GetPlatform().VisualScale(); + 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(); - m_tileDrawer = make_shared_ptr(new DrawerYG(params)); + m_tileDrawer = make_shared_ptr(new DrawerYG(p)); m_tileDrawer->onSize(tileWidth, tileHeight); m2::RectI renderRect(1, 1, tileWidth - 1, tileWidth - 1); @@ -57,7 +97,7 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr const & e, ScreenBas { DrawerYG * pDrawer = e->drawer(); - pDrawer->screen()->clear(bgColor()); + pDrawer->screen()->clear(m_bgColor); m_infoLayer.clear(); @@ -93,7 +133,7 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr const & e, ScreenBas { m_tileCache.readUnlock(); shared_ptr paintEvent(new PaintEvent(m_tileDrawer.get())); - shared_ptr tileTarget = resourceManager()->renderTargets()->Reserve(); + shared_ptr tileTarget = m_resourceManager->renderTargets()->Reserve(); shared_ptr tileInfoLayer(new yg::InfoLayer()); @@ -102,10 +142,10 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr const & e, ScreenBas m_tileDrawer->beginFrame(); - yg::Color c = bgColor(); + yg::Color c = m_bgColor; m_tileDrawer->clear(yg::Color(c.r, c.g, c.b, 0)); - m2::RectI renderRect(1, 1, resourceManager()->tileTextureWidth() - 1, resourceManager()->tileTextureHeight() - 1); + m2::RectI renderRect(1, 1, m_resourceManager->tileTextureWidth() - 1, m_resourceManager->tileTextureHeight() - 1); m_tileDrawer->screen()->setClipRect(renderRect); m_tileDrawer->clear(c); @@ -119,18 +159,18 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr const & e, ScreenBas m_tileScreen.PtoG(m2::RectD(renderRect), selectRect); m_tileScreen.PtoG(m2::Inflate(m2::RectD(renderRect), inflationSize, inflationSize), clipRect); - renderFn()(paintEvent, - m_tileScreen, - selectRect, - clipRect, - ri.m_drawScale); + 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, resourceManager())); + m_tileCache.addTile(ri, TileCache::Entry(tile, m_resourceManager)); m_tileCache.writeUnlock(); m_tileCache.readLock(); @@ -146,7 +186,12 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr const & e, ScreenBas m2::RectI(0, 0, tileWidth - 2, tileHeight - 2), m2::RectU(1, 1, tileWidth - 1, tileHeight - 1)); - windowHandle()->invalidate(); + m_windowHandle->invalidate(); } } } + +bool TilingRenderPolicyST::IsTiling() const +{ + return true; +} diff --git a/map/tiling_render_policy_st.hpp b/map/tiling_render_policy_st.hpp index 211158aea4..0eda1766d7 100644 --- a/map/tiling_render_policy_st.hpp +++ b/map/tiling_render_policy_st.hpp @@ -1,6 +1,7 @@ #pragma once #include "render_policy.hpp" +#include "drawer_yg.hpp" #include "tiler.hpp" #include "tile_cache.hpp" @@ -10,8 +11,16 @@ #include "../geometry/screenbase.hpp" -class DrawerYG; class WindowHandle; +class VideoTimer; + +namespace yg +{ + namespace gl + { + class RenderContext; + } +} class TilingRenderPolicyST : public RenderPolicy { @@ -27,11 +36,11 @@ private: public: - TilingRenderPolicyST(shared_ptr const & windowHandle, - RenderPolicy::TRenderFn const & renderFn); - - void Initialize(shared_ptr const & renderContext, - shared_ptr const & resourceManager); + TilingRenderPolicyST(VideoTimer * videoTimer, + DrawerYG::Params const & params, + shared_ptr const & primaryRC); void DrawFrame(shared_ptr const & paintEvent, ScreenBase const & screenBase); + + bool IsTiling() const; }; diff --git a/qt/draw_widget.cpp b/qt/draw_widget.cpp index 5e5d3c9651..ae41422000 100644 --- a/qt/draw_widget.cpp +++ b/qt/draw_widget.cpp @@ -7,7 +7,7 @@ #include #include "../map/framework_factory.hpp" - +#include "../map/render_policy.hpp" using namespace storage; @@ -45,33 +45,21 @@ namespace qt } DrawWidget::DrawWidget(QWidget * pParent) - : base_type(pParent), - m_handle(new WindowHandle()), + : QGLWidget(pParent), m_isInitialized(false), m_isTimerStarted(false), - m_framework(FrameworkFactory::CreateFramework(m_handle, 0)), + m_framework(FrameworkFactory::CreateFramework()), m_isDrag(false), m_isRotate(false), m_redrawInterval(100), m_pScale(0) { m_timer = new QTimer(this); - m_handle->setUpdatesEnabled(false); - -#ifdef OMIM_OS_MAC - m_videoTimer.reset(CreateAppleVideoTimer(bind(&DrawWidget::DrawFrame, this))); -#else - m_videoTimer.reset(new QtVideoTimer(this, bind(&DrawWidget::DrawFrame, this))); -#endif - - m_handle->setVideoTimer(m_videoTimer); - connect(m_timer, SIGNAL(timeout()), this, SLOT(ScaleTimerElapsed())); } void DrawWidget::PrepareShutdown() { - m_videoTimer->stop(); m_framework->PrepareToShutdown(); } @@ -84,7 +72,7 @@ namespace qt void DrawWidget::UpdateNow() { - m_framework->Invalidate(); + update(); } void DrawWidget::UpdateAfterSettingsChanged() @@ -98,7 +86,7 @@ namespace qt if (!Settings::Get("DrawWidgetSize", widthAndHeight)) return false; - m_framework->OnSize(widthAndHeight.first, widthAndHeight.second); + m_framework->OnSize(widthAndHeight.first, widthAndHeight.second); if (!m_framework->LoadState()) return false; @@ -116,11 +104,6 @@ namespace qt m_framework->SaveState(); } - //void DrawWidget::ShowFeature(Feature const & p) - //{ - // m_framework.ShowFeature(p); - //} - void DrawWidget::MoveLeft() { m_framework->Move(math::pi, 0.5); @@ -185,6 +168,15 @@ namespace qt m_framework->Invalidate(); } + VideoTimer * DrawWidget::CreateVideoTimer() + { +#ifdef OMIM_OS_MAC + return CreateAppleVideoTimer(bind(&DrawWidget::DrawFrame, this)); +#else + return new QtVideoTimer(this, bind(&DrawWidget::DrawFrame, this)); +#endif + } + void DrawWidget::ScaleChanged(int action) { if (action != QAbstractSlider::SliderNoAction) @@ -200,10 +192,49 @@ namespace qt void DrawWidget::initializeGL() { - widget_type::initializeGL(); - m_handle->setRenderContext(renderContext()); - m_framework->InitializeGL(renderContext(), resourceManager()); - m_isInitialized = true; +#ifdef OMIM_OS_WINDOWS + win32::InitOpenGL(); +#endif + + /// we'll perform swap by ourselves, see issue #333 + setAutoBufferSwap(false); + + if (!m_isInitialized) + { + VideoTimer * videoTimer = CreateVideoTimer(); + + DrawerYG::Params params; + params.m_frameBuffer = make_shared_ptr(new yg::gl::FrameBuffer(true)); + + shared_ptr primaryRC(new qt::gl::RenderContext(this)); + + m_framework->SetRenderPolicy(CreateRenderPolicy(videoTimer, params, primaryRC)); + + m_isInitialized = true; + } + } + + void DrawWidget::resizeGL(int w, int h) + { + m_framework->OnSize(w, h); + m_framework->Invalidate(); + if (m_isInitialized && m_isTimerStarted) + DrawFrame(); + UpdateScaleControl(); + emit ViewportChanged(); + } + + void DrawWidget::paintGL() + { + if ((m_isInitialized) && (!m_isTimerStarted)) + { + /// timer should be started upon the first repaint + /// request to fully initialized GLWidget. + m_isTimerStarted = true; + m_framework->SetUpdatesEnabled(true); + } + + m_framework->Invalidate(); } void DrawWidget::DrawFrame() @@ -213,7 +244,7 @@ namespace qt makeCurrent(); m_framework->SetNeedRedraw(false); - shared_ptr paintEvent(new PaintEvent(GetDrawer().get())); + shared_ptr paintEvent(new PaintEvent(m_framework->GetRenderPolicy()->GetDrawer().get())); m_framework->BeginPaint(paintEvent); m_framework->DoPaint(paintEvent); @@ -226,30 +257,6 @@ namespace qt } } - void DrawWidget::DoDraw(shared_ptr p) - { - if ((m_isInitialized) && (!m_isTimerStarted)) - { - /// timer should be started upon the first repaint - /// request to fully initialized GLWidget. - m_isTimerStarted = true; - m_handle->setUpdatesEnabled(true); - m_handle->invalidate(); - } - - m_framework->Invalidate(); - } - - void DrawWidget::DoResize(int w, int h) - { - m_framework->OnSize(w, h); - m_framework->Invalidate(); - if (m_isInitialized && m_isTimerStarted) - DrawFrame(); - UpdateScaleControl(); - emit ViewportChanged(); - } - namespace { DragEvent get_drag_event(QMouseEvent * e) @@ -266,7 +273,7 @@ namespace qt void DrawWidget::mousePressEvent(QMouseEvent * e) { - base_type::mousePressEvent(e); + QGLWidget::mousePressEvent(e); if (e->button() == Qt::LeftButton) { @@ -290,7 +297,7 @@ namespace qt void DrawWidget::mouseDoubleClickEvent(QMouseEvent * e) { - base_type::mouseDoubleClickEvent(e); + QGLWidget::mouseDoubleClickEvent(e); if (e->button() == Qt::LeftButton) { @@ -305,7 +312,7 @@ namespace qt void DrawWidget::mouseMoveEvent(QMouseEvent * e) { - base_type::mouseMoveEvent(e); + QGLWidget::mouseMoveEvent(e); if (m_isDrag) m_framework->DoDrag(get_drag_event(e)); @@ -316,7 +323,7 @@ namespace qt void DrawWidget::mouseReleaseEvent(QMouseEvent * e) { - base_type::mouseReleaseEvent(e); + QGLWidget::mouseReleaseEvent(e); StopDragging(e); StopRotating(e); @@ -326,7 +333,7 @@ namespace qt void DrawWidget::keyReleaseEvent(QKeyEvent * e) { - base_type::keyReleaseEvent(e); + QGLWidget::keyReleaseEvent(e); StopRotating(e); diff --git a/qt/draw_widget.hpp b/qt/draw_widget.hpp index 11524140c9..d7ac39abd8 100644 --- a/qt/draw_widget.hpp +++ b/qt/draw_widget.hpp @@ -17,9 +17,6 @@ namespace qt { class QScaleSlider; - /// Replace this to set a draw widget kernel. - typedef GLDrawWidget widget_type; - class DrawWidget; class QtVideoTimer : public ::VideoTimer @@ -40,22 +37,15 @@ namespace qt void stop(); }; - class DrawWidget : public widget_type + class DrawWidget : public QGLWidget { - typedef widget_type base_type; + typedef model::FeaturesFetcher model_t; - shared_ptr m_handle; - - shared_ptr m_drawer; bool m_isInitialized; bool m_isTimerStarted; - typedef model::FeaturesFetcher model_t; - scoped_ptr > m_framework; - shared_ptr m_videoTimer; - bool m_isDrag; bool m_isRotate; @@ -105,14 +95,18 @@ namespace qt Framework & GetFramework() { return *m_framework.get(); } protected: + + VideoTimer * CreateVideoTimer(); + static const uint32_t ini_file_version = 0; protected: + /// @name Overriden from base_type. //@{ virtual void initializeGL(); - virtual void DoDraw(shared_ptr p); - virtual void DoResize(int w, int h); + virtual void resizeGL(int w, int h); + virtual void paintGL(); //@} void DrawFrame(); diff --git a/qt/widgets.hpp b/qt/widgets.hpp index 9a7f2c1130..cb56361f87 100644 --- a/qt/widgets.hpp +++ b/qt/widgets.hpp @@ -5,6 +5,7 @@ #include "../yg/resource_manager.hpp" class DrawerYG; +class VideoTimer; namespace yg { @@ -19,10 +20,12 @@ namespace qt /// Widget uses yg for drawing. class GLDrawWidget : public GLDrawWidgetT { + typedef GLDrawWidgetT base_type; shared_ptr m_renderContext; protected: + shared_ptr m_resourceManager; public: diff --git a/yg/geometry_batcher.cpp b/yg/geometry_batcher.cpp index ff94e8d57f..e973b1435c 100644 --- a/yg/geometry_batcher.cpp +++ b/yg/geometry_batcher.cpp @@ -88,10 +88,10 @@ namespace yg shared_ptr freeStorage(new FreeStorage()); - freeStorage->m_storage = pipeline.m_storage; - if (pipeline.m_hasStorage) { + freeStorage->m_storage = pipeline.m_storage; + if (pipeline.m_useTinyStorage) freeStorage->m_storagePool = resourceManager()->tinyStorages(); else @@ -102,9 +102,9 @@ namespace yg pipeline.m_hasStorage = false; pipeline.m_storage = Storage(); - } - processCommand(freeStorage); + processCommand(freeStorage); + } } void GeometryBatcher::setAdditionalSkinPage(shared_ptr const & p)