Merge lp:~smspillaz/unity/unity.fix_1080947 into lp:unity

[Sam Spilsbury]

Don't re-present all of our windows on every frame. Only do that if damage intersects it.

Use the new APIs exposed by compiz and nux to intelligently determine which windows need to be presented per-frame and only register damage for those windows. This fixes two things:

1. BaseWindows being redrawn from scratch every time damage was registered over them. That was incorrect and should only be done in the case of background blurs.
2. BaseWindows being drawn to the screen on every frame, regardless of whether or not they needed to be. Now they will only be drawn if some damage intersects beneath them. Note that unity will expand the damage region to accomadate the base window since nux does not support geometry clipping. So if there is a partial intersection of the launcher for example, the area of the screen which contains the launcher will be re-painted (but the launcher itself won't be redrawn, just its texture).

This also uses the framebuffer blitting API from compiz to quickly copy the non-blurred regions of the screen back to the backbuffer.

(LP: #1080947)

Don't re-present all of our windows on every frame. Only do that if damage intersects it.

Use the new APIs exposed by compiz and nux to intelligently determine which windows need to be presented per-frame and only register damage for those windows. This fixes two things:

1. BaseWindows being redrawn from scratch every time damage was registered over them. That was incorrect and should only be done in the case of background blurs.
2. BaseWindows being drawn to the screen on every frame, regardless of whether or not they needed to be. Now they will only be drawn if some damage intersects beneath them. Note that unity will expand the damage region to accomadate the base window since nux does not support geometry clipping. So if there is a partial intersection of the launcher for example, the area of the screen which contains the launcher will be re-painted (but the launcher itself won't be redrawn, just its texture).

This also uses the framebuffer blitting API from compiz to quickly copy the non-blurred regions of the screen back to the backbuffer.

(LP: #1080947)

This branch depends on two others:

1. https://code.launchpad.net/~smspillaz/nux/nux.fix_1091589/+merge/147543 (WindowThread::PresentWindowsIntersectingGeometryOnThisFrame, WindowThread::ForeignFrameCutoff, WindowThread::ForeignFrameEnded)
2. https://code.launchpad.net/~compiz-team/compiz/compiz.fix_1024304/+merge/147540 (composite::Frameroster)

Update: test results here: http://www.ucc.asn.au/~smspillaz/phoronix-test-suite/composite.xml

I was careful to modify phoronix-test-suite to run tests in windowed mode only, and those were the only three tests I was able to get to run in windowed mode. Of particular interest was the fact that the unigine demos had a 5x performance improvement, probably because the driver was spending less time filling redundant pixels from the compositor. In other areas we had a roughly 5FPS boost.

Compiz framerate graph:

http://www.ucc.asn.au/~smspillaz/compiz-perf-graph.png

You'll see that especially on the last test, it drops off quite a bit on the non buffer_age case, and is generally speaking lower across the board.

=== modified file 'launcher/XdndCollectionWindowImp.cpp'
--- launcher/XdndCollectionWindowImp.cpp	2012-11-22 16:37:07 +0000
+++ launcher/XdndCollectionWindowImp.cpp	2013-02-10 09:01:22 +0000
@@ -38,7 +38,8 @@
     auto uscreen = UScreen::GetDefault();
     SetGeometry(uscreen->GetScreenGeometry());
 
-    ShowWindow(true);
+    // We are not calling ShowWindow () as this window
+    // isn't really visible
     PushToBack();
     // Hack to create the X Window as soon as possible.
     EnableInputWindow(true, "XdndCollectionWindowImp");

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-02-08 18:31:30 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-02-10 09:01:22 +0000
@@ -25,6 +25,8 @@
 #include <Nux/BaseWindow.h>
 #include <Nux/WindowCompositor.h>
 
+#include <opengl/framebufferobject.h>
+
 #include <UnityCore/Variant.h>
 #include <UnityCore/Lens.h>
 
@@ -78,6 +80,8 @@
 /* Set up vtable symbols */
 COMPIZ_PLUGIN_20090315(unityshell, unity::UnityPluginVTable);
 
+namespace cgl = compiz::opengl;
+
 namespace unity
 {
 using namespace launcher;
@@ -150,6 +154,9 @@
   , scale_just_activated_(false)
   , big_tick_(0)
   , screen_introspection_(screen)
+  , ignore_redraw_request_(false)
+  , previous_framebuffer_(nullptr)
+  , directly_drawable_buffer_age_(0)
 {
   Timer timer;
 #ifndef USE_GLES
@@ -413,8 +420,17 @@
     WindowManager& wm = WindowManager::Default();
     wm.initiate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnInitiateSpread));
     wm.terminate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnTerminateSpread));
+    wm.initiate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
+    wm.terminate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
 
     AddChild(&screen_introspection_);
+
+    /* Setup our render target for scraping the blur texture */
+    directly_drawable_fbo_.reset(cgl::createBlittableFramebufferObjectWithFallback(*screen,
+                                                                                   gScreen));
+
+    /* Track whole damage on the very first frame */
+    cScreen->damageScreen();
   }
 }
 
@@ -471,7 +487,6 @@
   {
     LOG_WARN(logger) << "Could not find key above tab!";
   }
-
 }
 
 void UnityScreen::OnInitiateSpread()
@@ -490,6 +505,31 @@
   UnityWindow::CleanupSharedTextures();
 }
 
+void UnityScreen::DamagePanelShadow()
+{
+  CompRect panelShadow;
+
+  for (CompOutput &output : screen->outputDevs())
+  {
+    FillShadowRectForOutput(panelShadow, &output);
+    cScreen->damageRegion(CompRegion(panelShadow));
+  }
+}
+
+void UnityScreen::OnViewHidden(nux::BaseWindow *bw)
+{
+  /* Count this as regular damage */
+  nux::Geometry geometry(bw->GetAbsoluteGeometry());
+  cScreen->damageRegion(CompRegion (geometry.x,
+                                    geometry.y,
+                                    geometry.width,
+                                    geometry.height));
+}
+
+void UnityScreen::OnViewShown(nux::BaseWindow *bw)
+{
+}
+
 void UnityScreen::EnsureSuperKeybindings()
 {
   for (auto action : _shortcut_actions)
@@ -581,7 +621,18 @@
   panel_shadow_matrix_ = matrix;
 }
 
-void UnityScreen::paintPanelShadow(const CompRegion& clip)
+void UnityScreen::FillShadowRectForOutput(CompRect &shadowRect,
+                                          CompOutput *output)
+{
+  float panel_h = static_cast<float>(panel_style_.panel_height);
+  float shadowX = output->x();
+  float shadowY = output->y() + panel_h;
+  float shadowWidth = output->width();
+  float shadowHeight = _shadow_texture[0]->height();
+  shadowRect.setGeometry(shadowX, shadowY, shadowWidth, shadowHeight);
+}
+
+void UnityScreen::PaintPanelShadow(const CompRegion& clip)
 {
   if (panel_controller_->opacity() == 0.0f)
     return;
@@ -597,17 +648,13 @@
   if (fullscreenRegion.contains(*output))
     return;
 
-  float panel_h = static_cast<float>(panel_style_.panel_height);
-
   // You have no shadow texture. But how?
   if (_shadow_texture.empty() || !_shadow_texture[0])
     return;
 
-  float shadowX = output->x();
-  float shadowY = output->y() + panel_h;
-  float shadowWidth = output->width();
-  float shadowHeight = _shadow_texture[0]->height();
-  CompRect shadowRect(shadowX, shadowY, shadowWidth, shadowHeight);
+  CompRect shadowRect;
+
+  FillShadowRectForOutput(shadowRect, output);
 
   CompRegion redraw(clip);
   redraw &= shadowRect;
@@ -669,10 +716,10 @@
       float y2 = r.y2();
 
       // Texture coordinates of the above rectangle:
-      float tx1 = (x1 - shadowX) / shadowWidth;
-      float ty1 = (y1 - shadowY) / shadowHeight;
-      float tx2 = (x2 - shadowX) / shadowWidth;
-      float ty2 = (y2 - shadowY) / shadowHeight;
+      float tx1 = (x1 - shadowRect.x()) / shadowRect.width();
+      float ty1 = (y1 - shadowRect.y()) / shadowRect.height();
+      float tx2 = (x2 - shadowRect.x()) / shadowRect.width();
+      float ty2 = (y2 - shadowRect.y()) / shadowRect.height();
 
       vertexData = {
         x1, y1, 0,
@@ -739,26 +786,59 @@
 
   DrawTopPanelBackground();
 
-  auto gpu_device = nux::GetGraphicsDisplay()->GetGpuDevice();
-
-  if (BackgroundEffectHelper::HasDirtyHelpers())
+  if (previous_framebuffer_)
   {
-    auto graphics_engine = nux::GetGraphicsDisplay()->GetGraphicsEngine();
-    nux::ObjectPtr<nux::IOpenGLTexture2D> bg_texture =
-      graphics_engine->CreateTextureFromBackBuffer(0, 0,
-                                                   screen->width(),
-                                                   screen->height());
-    gpu_device->backup_texture0_ = bg_texture;
+    gScreen->bindFramebufferForDrawing(previous_framebuffer_);
+
+    CompRegion direct_draw_region =
+        CompRegionRef (output->region()) & buffered_compiz_damage_last_frame_;
+    CompRect::vector direct_draw_rects (direct_draw_region.rects());
+
+    /* Set viewport to fullscreen */
+    glViewport (0, 0, screen->width(), screen->height());
+
+    for (const CompRect &r : direct_draw_rects)
+    {
+      /* For now we should invert the y co-ords */
+      directly_drawable_fbo_->directDraw (r,
+                                          r,
+                                          compiz::opengl::ColorData,
+                                          compiz::opengl::Fast);
+    }
+
+    glViewport(output->x(),
+               screen->height () - output->y2(),
+               output->width(),
+               screen->height());
+
+    nux::ObjectPtr<nux::IOpenGLTexture2D> bg_texture
+        (nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(directly_drawable_fbo_->tex()->name(),
+                                           screen->width(), screen->height(),
+                                           0,
+                                           nux::BITFMT_R8G8B8A8));
+    nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = bg_texture;
+    previous_framebuffer_ = nullptr;
   }
 
+  /* Bind the currently bound draw framebuffer to the read framebuffer binding.
+   * The reason being that we want to use the results of nux images being
+   * drawn to this framebuffer in glCopyTexSubImage2D operations */
+  gScreen->bindFramebufferForReading(gScreen->drawFramebuffer());
+
   nux::Geometry geo(0, 0, screen->width (), screen->height ());
   nux::Geometry outputGeo(output->x (), output->y (), output->width (), output->height ());
   BackgroundEffectHelper::monitor_rect_ = geo;
 
-  GLint fboID;
+  GLint dFBOID, rFBOID;
   // Nux renders to the referenceFramebuffer when it's embedded.
-  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fboID);
-  wt->GetWindowCompositor().SetReferenceFramebuffer(fboID, outputGeo);
+#ifndef USE_GLES
+  glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dFBOID);
+  glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rFBOID);
+#else
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &dFBOID);
+  rFBOID = dFBOID;
+#endif
+  wt->GetWindowCompositor().SetReferenceFramebuffer(dFBOID, rFBOID, outputGeo);
 
   nuxPrologue();
   _in_paint = true;
@@ -1260,6 +1340,7 @@
   doShellRepaint = force ||
                    ( !region.isEmpty() &&
                      ( !wt->GetDrawList().empty() ||
+                       !wt->GetPresentationListGeometries().empty() ||
                        (mask & PAINT_SCREEN_FULL_MASK)
                      )
                    );
@@ -1272,6 +1353,14 @@
   fullscreenRegion = CompRegion();
   nuxRegion = CompRegion();
 
+  // bind the framebuffer if we plan to paint nux on this frame
+  if (doShellRepaint && BackgroundEffectHelper::HasDirtyHelpers())
+  {
+    previous_framebuffer_ =
+        gScreen->bindFramebufferForDrawing(directly_drawable_fbo_.get());
+    directly_drawable_buffer_age_ = 0;
+  }
+
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
 
@@ -1294,8 +1383,86 @@
                                            unsigned int mask)
 {
   allowWindowPaint = false;
+
+  /* PAINT_SCREEN_FULL_MASK means that we are ignoring the damage
+   * region and redrawing the whole screen, so we should make all
+   * nux windows be added to the presentation list that intersect
+   * this output.
+   *
+   * However, damaging nux has a side effect of notifying compiz
+   * through onRedrawRequested that we need to queue another frame.
+   * In most cases that would be desirable, and in the case where
+   * we did that in damageCutoff, it would not be a problem as compiz
+   * does not queue up new frames for damage that can be processed
+   * on the current frame. However, we're now past damage cutoff, but
+   * a change in circumstances has required that we redraw all the nux
+   * windows on this frame. As such, we need to ensure that damagePending
+   * is not called as a result of queuing windows for redraw, as that
+   * would effectively result in a damage feedback loop in plugins that
+   * require screen transformations (eg, new frame -> plugin redraws full
+   * screen -> we reach this point and request another redraw implicitly)
+   */
+  if (mask & PAINT_SCREEN_FULL_MASK)
+  {
+    ignore_redraw_request_ = true;
+    compizDamageNux(CompRegionRef(output->region()));
+    ignore_redraw_request_ = false;
+
+    std::vector<nux::Geometry> dirty = wt->GetPresentationListGeometries();
+  }
+
   gScreen->glPaintTransformedOutput(attrib, transform, region, output, mask);
-  paintPanelShadow(region);
+  PaintPanelShadow(region);
+}
+
+
+
+void UnityScreen::damageCutoff()
+{
+  /* If there are enabled helpers, we want to apply damage
+   * based on how old our tracking fbo is since we may need
+   * to redraw some of the blur regions if there has been
+   * damage since we last bound it
+   *
+   * XXX: Unfortunately there's a nasty feedback loop here, and not
+   * a whole lot we can do about it. If part of the damage from any frame
+   * intersects a nux window, we have to mark the entire region that the
+   * nux window covers as damaged, because nux does not have any concept
+   * of geometry clipping. That damage will feed back to us on the next frame.
+   */
+  if (BackgroundEffectHelper::HasEnabledHelpers())
+    cScreen->applyDamageForFrameAge (directly_drawable_buffer_age_);
+
+  /* Determine nux region damage last */
+  cScreen->damageCutoff();
+
+  CompRegion damage_buffer, last_damage_buffer;
+
+  do
+  {
+    last_damage_buffer = damage_buffer;
+
+    /* First apply any damage accumulated to nux to see
+     * what windows need to be redrawn there */
+    compizDamageNux(buffered_compiz_damage_this_frame_);
+
+    /* Apply the redraw regions to compiz so that we can
+     * draw this frame with that region included */
+    determineNuxDamage(damage_buffer);
+
+    /* We want to track the nux damage here as we will use it to
+     * determine if we need to present other nux windows too */
+    cScreen->damageRegion(damage_buffer);
+
+    /* If we had to put more damage into the damage buffer then
+     * damage compiz with it and keep going */
+  } while (last_damage_buffer != damage_buffer);
+
+  /* Clear damage buffer */
+  buffered_compiz_damage_last_frame_ = buffered_compiz_damage_this_frame_;
+  buffered_compiz_damage_this_frame_ = CompRegion();
+
+  wt->ForeignFrameCutoff();
 }
 
 void UnityScreen::preparePaint(int ms)
@@ -1311,8 +1478,6 @@
   didShellRepaint = false;
   panelShadowPainted = CompRegion();
   firstWindowAboveShell = NULL;
-
-  compizDamageNux(cScreen->currentDamage());
 }
 
 void UnityScreen::donePaint()
@@ -1326,11 +1491,20 @@
    * I think this is a Nux bug. ClearDrawList should ideally also mark all
    * the queued views as draw_cmd_queued_=false.
    */
+
+  /* To prevent any potential overflow problems, we are assuming here
+   * that compiz caps the maximum number of frames tracked at 10, so
+   * don't increment the age any more than 11 */
+  if (directly_drawable_buffer_age_ < 11)
+    ++directly_drawable_buffer_age_;
+
   if (didShellRepaint)
     wt->ClearDrawList();
 
+  wt->ForeignFrameEnded();
+
   if (animation_controller_->HasRunningAnimations())
-    nuxDamageCompiz();
+    onRedrawRequested();
 
   std::list <ShowdesktopHandlerWindowInterface *> remove_windows;
 
@@ -1376,103 +1550,52 @@
     }
   }
 
-  auto const& launchers = launcher_controller_->launchers();
-  for (auto const& launcher : launchers)
-  {
-    if (!launcher->Hidden())
-    {
-      nux::Geometry const& geo = launcher->GetAbsoluteGeometry();
-      CompRegion launcher_region(geo.x, geo.y, geo.width, geo.height);
-
-      if (damage.intersects(launcher_region))
-        launcher->QueueDraw();
-
-      nux::ObjectPtr<nux::View> const& tooltip = launcher->GetActiveTooltip();
-
-      if (tooltip)
-      {
-        nux::Geometry const& g = tooltip->GetAbsoluteGeometry();
-        CompRegion tip_region(g.x, g.y, g.width, g.height);
-
-        if (damage.intersects(tip_region))
-          tooltip->QueueDraw();
-      }
-
-      nux::ObjectPtr<LauncherDragWindow> const& dragged_icon = launcher->GetDraggedIcon();
-
-      if (dragged_icon)
-      {
-        nux::Geometry const& g = dragged_icon->GetAbsoluteGeometry();
-        CompRegion icon_region(g.x, g.y, g.width, g.height);
-
-        if (damage.intersects(icon_region))
-          dragged_icon->QueueDraw();
-      }
-    }
-  }
-
-  std::vector<nux::View*> const& panels(panel_controller_->GetPanelViews());
-  for (nux::View* view : panels)
-  {
-    nux::Geometry const& geo = view->GetAbsoluteGeometry();
-
-    CompRegion panel_region(geo.x, geo.y, geo.width, geo.height);
-
-    if (damage.intersects(panel_region))
-      view->QueueDraw();
-  }
-
-  QuicklistManager* qm = QuicklistManager::Default();
-  if (qm)
-  {
-    auto const& view = qm->Current();
-
-    if (view)
-    {
-      nux::Geometry const& geo = view->GetAbsoluteGeometry();
-      CompRegion quicklist_region(geo.x, geo.y, geo.width, geo.height);
-
-      if (damage.intersects(quicklist_region))
-        view->QueueDraw();
-    }
-  }
-
-  if (switcher_controller_ && switcher_controller_->Visible())
-  {
-    auto const& view = switcher_controller_->GetView();
-
-    if (G_LIKELY(view))
-    {
-      nux::Geometry const& geo = view->GetAbsoluteGeometry();
-      CompRegion switcher_region(geo.x, geo.y, geo.width, geo.height);
-
-      if (damage.intersects(switcher_region))
-        view->QueueDraw();
-    }
+  /* Ask nux to present anything in our damage region
+   *
+   * Note: This is using a new nux API, to "present" windows
+   * to the screen, as opposed to drawing them. The difference is
+   * important. The former will just draw the window backing texture
+   * directly to the screen, the latter will re-draw the entire window.
+   *
+   * The former is a lot faster, do not use QueueDraw unless the contents
+   * of the window need to be re-drawn.
+   */
+  CompRect::vector rects (damage.rects());
+  for (const CompRect &r : rects)
+  {
+    nux::Geometry g (r.x(), r.y(), r.width(), r.height());
+    wt->PresentWindowsIntersectingGeometryOnThisFrame(g);
   }
 }
 
 /* Grab changed nux regions and add damage rects for them */
-void UnityScreen::nuxDamageCompiz()
+void UnityScreen::determineNuxDamage(CompRegion &nux_damage)
 {
-  /*
-   * If Nux is going to redraw anything then we have to tell Compiz to
-   * redraw everything. This is because Nux has a bad habit (bug??) of drawing
-   * more than just the regions of its DrawList. (LP: #1036519)
-   *
-   * Forunately, this does not happen on most frames. Only when the Unity
-   * Shell needs to redraw something.
-   *
-   * TODO: Try to figure out why redrawing the panel makes the launcher also
-   *       redraw even though the launcher's geometry is not in DrawList, and
-   *       stop it. Then maybe we can revert back to the old code below #else.
-   */
-  std::vector<nux::Geometry> const& dirty = wt->GetDrawList();
-  if (!dirty.empty() || animation_controller_->HasRunningAnimations())
+  if (!launcher_controller_ || !dash_controller_)
+    return;
+
+  std::vector<nux::Geometry> dirty = wt->GetPresentationListGeometries();
+
+  for (auto const& geo : dirty)
+    nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
+
+  /* Special case, we need to redraw the panel shadow on panel updates */
+  for (auto const& panel_geo : panel_controller_->GetGeometries())
   {
-    cScreen->damageRegionSetEnabled(this, false);
-    cScreen->damageScreen();
-    cScreen->damageRegionSetEnabled(this, true);
+    CompRect panel_rect (panel_geo.x,
+                         panel_geo.y,
+                         panel_geo.width,
+                         panel_geo.height);
+
+    if (nux_damage.intersects(panel_rect))
+    {
+      foreach (CompOutput &o, screen->outputDevs())
+      {
+        CompRect shadowRect;
+        FillShadowRectForOutput(shadowRect, &o);
+        nux_damage += shadowRect;
+      }
+    }
   }
 }
 
@@ -1712,7 +1835,7 @@
 
 void UnityScreen::damageRegion(const CompRegion &region)
 {
-  compizDamageNux(region);
+  buffered_compiz_damage_this_frame_ += region;
   cScreen->damageRegion(region);
 }
 
@@ -2606,7 +2729,7 @@
       window->id() == active_window &&
       window->type() != CompWindowTypeDesktopMask)
   {
-    uScreen->paintPanelShadow(region);
+    uScreen->PaintPanelShadow(region);
   }
 
   bool ret = gWindow->glDraw(matrix, attrib, region, mask);
@@ -2615,7 +2738,7 @@
       (active_window == 0 || active_window == window->id()) &&
       (window->type() == CompWindowTypeDesktopMask))
   {
-    uScreen->paintPanelShadow(region);
+    uScreen->PaintPanelShadow(region);
   }
 
   return ret;
@@ -2938,11 +3061,15 @@
   nux::ColorLayer background(nux::color::Transparent);
   static_cast<nux::WindowThread*>(thread)->SetWindowBackgroundPaintLayer(&background);
   LOG_INFO(logger) << "UnityScreen::initUnity: " << timer.ElapsedSeconds() << "s";
+
+  nux::GetWindowCompositor().sigHiddenViewWindow.connect (sigc::mem_fun(self, &UnityScreen::OnViewHidden));
+  nux::GetWindowCompositor().sigVisibleViewWindow.connect (sigc::mem_fun(self, &UnityScreen::OnViewShown));
 }
 
 void UnityScreen::onRedrawRequested()
 {
-  nuxDamageCompiz();
+  if (!ignore_redraw_request_)
+    cScreen->damagePending();
 }
 
 /* Handle option changes and plug that into nux windows */
@@ -3132,6 +3259,8 @@
                     << " h=" << primary_monitor_().height;
 
   needsRelayout = false;
+
+  DamagePanelShadow ();
 }
 
 /* Handle changes in the number of workspaces by showing the switcher
@@ -3163,6 +3292,17 @@
 {
   screen->outputChangeNotify ();
 
+  /* Unbind and reallocate the directly drawable fbo */
+  cgl::BindableFramebuffer *old_read_buffer =
+      gScreen->bindFramebufferForReading(gScreen->backbuffer());
+  cgl::BindableFramebuffer *old_draw_buffer =
+      gScreen->bindFramebufferForDrawing(gScreen->backbuffer());
+
+  directly_drawable_fbo_->allocate (*screen, NULL, GL_BGRA);
+
+  gScreen->bindFramebufferForReading(old_read_buffer);
+  gScreen->bindFramebufferForDrawing(old_draw_buffer);
+
   ScheduleRelayout(500);
 }
 

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2013-02-06 17:30:10 +0000
+++ plugins/unityshell/src/unityshell.h	2013-02-10 09:01:22 +0000
@@ -96,9 +96,10 @@
 
   /* nux draw wrapper */
   void paintDisplay();
-  void paintPanelShadow(const CompRegion& clip);
+  void PaintPanelShadow(const CompRegion& clip);
   void setPanelShadowMatrix(const GLMatrix& matrix);
 
+  void damageCutoff();
   void preparePaint (int ms);
   void paintFboForOutput (CompOutput *output);
   void donePaint ();
@@ -214,7 +215,7 @@
   void initLauncher();
 
   void compizDamageNux(CompRegion const& region);
-  void nuxDamageCompiz();
+  void determineNuxDamage(CompRegion &nux_damage);
 
   void onRedrawRequested();
   void Relayout();
@@ -236,6 +237,13 @@
   void OnInitiateSpread();
   void OnTerminateSpread();
 
+  void DamagePanelShadow();
+
+  void OnViewHidden(nux::BaseWindow *bw);
+  void OnViewShown(nux::BaseWindow *bw);
+
+  void RestoreWindow(GVariant* data);
+
   bool SaveInputThenFocus(const guint xid);
 
   void OnPanelStyleChanged();
@@ -246,6 +254,8 @@
   bool TopPanelBackgroundTextureNeedsUpdate() const;
   void UpdateTopPanelBackgroundTexture();
 
+  void FillShadowRectForOutput(CompRect &shadowRect,
+                               CompOutput *output);
   unsigned CompizModifiersToNux(unsigned input) const;
   unsigned XModifiersToNux(unsigned input) const;
 
@@ -343,6 +353,14 @@
   UBusManager ubus_manager_;
   glib::SourceManager sources_;
 
+  CompRegion buffered_compiz_damage_this_frame_;
+  CompRegion buffered_compiz_damage_last_frame_;
+  bool       ignore_redraw_request_;
+
+  std::unique_ptr <compiz::opengl::DirectDrawObject> directly_drawable_fbo_;
+  compiz::opengl::BindableFramebuffer *previous_framebuffer_;
+  unsigned int directly_drawable_buffer_age_;
+
   friend class UnityWindow;
 };
 

=== modified file 'unity-shared/BackgroundEffectHelper.cpp'
--- unity-shared/BackgroundEffectHelper.cpp	2013-01-29 13:20:11 +0000
+++ unity-shared/BackgroundEffectHelper.cpp	2013-02-10 09:01:22 +0000
@@ -92,9 +92,7 @@
   for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
   {
     if (bg_effect_helper->enabled)
-    {
       return true;
-    }
   }
 
   return false;