made single-threaded rendering policies work on iOS devices.

iphone/Maps/Classes/EAGLView.mm

@@ -113,22 +113,22 @@
 
 - (void)onSize:(int)width withHeight:(int)height
 {
-	/// free old video memory
-	frameBuffer->resetRenderTarget();
-  frameBuffer->resetDepthBuffer();
-	renderBuffer.reset();
+  frameBuffer->onSize(width, height);
+  
+  shared_ptr<DrawerYG> drawer = framework->GetRenderPolicy()->GetDrawer();  
+
+  /// free old video memory
+  drawer->screen()->resetRenderTarget();
+  drawer->screen()->resetDepthBuffer();
+  renderBuffer.reset();
 
 	/// allocate the new one
-	renderBuffer = shared_ptr<iphone::RenderBuffer>(new iphone::RenderBuffer(renderContext, (CAEAGLLayer*)self.layer));
-	frameBuffer->setRenderTarget(renderBuffer);
-  frameBuffer->setDepthBuffer(make_shared_ptr(new yg::gl::RenderBuffer(width, height, true)));
-
-  framework->OnSize(width, height);
+	renderBuffer = make_shared_ptr(new iphone::RenderBuffer(renderContext, (CAEAGLLayer*)self.layer));
   
-/*  frameBuffer->onSize(width, height);
-	drawer->onSize(width, height);*/
+  drawer->screen()->setRenderTarget(renderBuffer);
+  drawer->screen()->setDepthBuffer(make_shared_ptr(new yg::gl::RenderBuffer(width, height, true)));
 
-  shared_ptr<DrawerYG> drawer = framework->GetRenderPolicy()->GetDrawer();
+  framework->OnSize(width, height);  
   
   drawer->screen()->beginFrame();
   drawer->screen()->clear(yg::gl::Screen::s_bgColor);

map/queued_render_policy.cpp

@@ -17,8 +17,7 @@ QueuedRenderPolicy::~QueuedRenderPolicy()
 
   delete [] m_Pipelines;
 
-  LOG(LINFO, ("resetting state"));
-  m_state.reset();
+  LOG(LINFO, ("deleted QueuedRenderPolicy"));
 }
 
 bool QueuedRenderPolicy::NeedRedraw() const
@@ -50,24 +49,21 @@ void QueuedRenderPolicy::EndFrame(shared_ptr<PaintEvent> const & ev, ScreenBase
 
 void QueuedRenderPolicy::DrawFrame(shared_ptr<PaintEvent> const & ev, ScreenBase const & s)
 {
-  if (!m_state)
-  {
-    m_state = ev->drawer()->screen()->createState();
-    m_state->m_isDebugging = m_IsDebugging;
-  }
+  shared_ptr<yg::gl::BaseState> state = ev->drawer()->screen()->createState();
+  state->m_isDebugging = m_IsDebugging;
 
-  ev->drawer()->screen()->getState(m_state.get());
+  ev->drawer()->screen()->getState(state.get());
 
   for (unsigned i = 0; i < m_PipelinesCount; ++i)
   {
-    RenderQueuedCommands(i);
+    RenderQueuedCommands(i, state);
     m_resourceManager->mergeFreeResources();
   }
 }
 
-void QueuedRenderPolicy::RenderQueuedCommands(int pipelineNum)
+void QueuedRenderPolicy::RenderQueuedCommands(int pipelineNum, shared_ptr<yg::gl::BaseState> const & state)
 {
-  shared_ptr<yg::gl::BaseState> curState = m_state;
+  shared_ptr<yg::gl::BaseState> curState = state;
 
   unsigned cmdProcessed = 0;
 
@@ -115,7 +111,7 @@ void QueuedRenderPolicy::RenderQueuedCommands(int pipelineNum)
     LOG(LINFO, (m_Pipelines[pipelineNum].m_Queue.Size(), "commands left"));
   }
 
-  m_state->apply(curState.get());
+  state->apply(curState.get());
 }
 
 void QueuedRenderPolicy::PacketsPipeline::FillFrameBucket(list<yg::gl::Packet> & renderQueue, int maxFrames)

map/queued_render_policy.hpp

@@ -30,13 +30,11 @@ private:
 
   bool m_IsDebugging;
 
-  shared_ptr<yg::gl::BaseState> m_state;
-
 protected:
 
   void CopyQueuedCommands(list<yg::gl::Packet> & l, list<yg::gl::Packet> & r);
 
-  void RenderQueuedCommands(int pipelineNum);
+  void RenderQueuedCommands(int pipelineNum, shared_ptr<yg::gl::BaseState> const & state);
   void DismissQueuedCommands(int pipelineNum);
 
 public:

yg/framebuffer.cpp

@@ -131,14 +131,14 @@ namespace yg
       GLenum res = glCheckFramebufferStatusFn(GL_FRAMEBUFFER_MWM);
       OGLCHECKAFTER;
       if (res == GL_FRAMEBUFFER_UNSUPPORTED_MWM)
-        LOG(LINFO, ("unsupported combination of attached target formats. could be possibly skipped"));
+        LOG(LINFO, ("unsupported combination of attached target formats. could be possibly skipped. id=", m_id));
       else if (res == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_MWM)
-        LOG(LINFO, ("incomplete attachement"));
+        LOG(LINFO, ("incomplete attachement. id=", m_id));
       else if (res == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_MWM)
-        LOG(LINFO, ("incomplete missing attachement"));
+        LOG(LINFO, ("incomplete missing attachement. id=", m_id));
       else if (res == GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_MWM)
       {
-        LOG(LINFO, ("incomplete dimensions"));
+        LOG(LINFO, ("incomplete dimensions. id=", m_id));
       }
     }
   }

yg/renderer.cpp

@@ -236,6 +236,13 @@ namespace yg
       }
     }
 
+    void Renderer::resetRenderTarget()
+    {
+      m_renderTarget.reset();
+      if (!m_renderQueue)
+        m_frameBuffer->resetRenderTarget();
+    }
+
     shared_ptr<RenderBuffer> const & Renderer::depthBuffer() const
     {
       return m_depthBuffer;
@@ -249,6 +256,14 @@ namespace yg
         m_frameBuffer->setDepthBuffer(rt);
     }
 
+    void Renderer::resetDepthBuffer()
+    {
+      m_depthBuffer.reset();
+
+      if (!m_renderQueue)
+        m_frameBuffer->resetDepthBuffer();
+    }
+
     Renderer::ClearCommand::ClearCommand(yg::Color const & color,
                                          bool clearRT,
                                          float depth,

yg/renderer.hpp

@@ -96,9 +96,11 @@ namespace yg
 
       void setRenderTarget(shared_ptr<RenderTarget> const & rt);
       shared_ptr<RenderTarget> const & renderTarget() const;
+      void resetRenderTarget();
 
       void setDepthBuffer(shared_ptr<RenderBuffer> const & rt);
       shared_ptr<RenderBuffer> const & depthBuffer() const;
+      void resetDepthBuffer();
 
       /// @param clearRT - should we clear the renderTarget data (visible pixels)?
       /// @param clearDepth - should we clear depthBuffer data?