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

[Sam Spilsbury]

Fix bug 868120 and bug 872625

We should use one framebuffer object per screen rather than one per monitor. Using one per monitor leads to all kinds of interesting rendering glitches because the plugins expect that paint is clipped to the entire backbuffer rather than paint being contained in one buffer.

This should also fix crashes on changing resolutions, as we don't have the race condition where a monitor paints and an fbo hasn't been created for it yet.

Also adds a testcase now, its in standalone-tests/TestScreenEffectFramebufferObject.cpp .

The testcase is a little quirky because we're trying to simulate what's going on when unity is actually running embedded in another opengl application, which means that we have to use nux's embedded mode rather than testing BackgroundEffectHelper directly. The testcase shows what happens in cases where parts of the scene are blurred and other parts aren't as well as what happens when some parts need updating and others don't (eg, the framebuffer should unbind). There's no automated test yet, but I imagine we could make one.

[Mirco Müller (macslow)]

This branch does break the repaint-cycle. While it compiles/works/runs screen-updates only happen when a window is moved. From the diff I currently don't see what you're missing.

review: Needs Fixing

[Mirco Müller (macslow)]

I tried this on my laptop (intel graphics, mesa) and it worked ok. So something odd is happening with nvidia (binary driver). Might need to see how ATI/fglrx behaves with this.

[Michal Hruby (mhr3)]

Nvidia here and I can confirm MacSlow's findings.

[Sam Spilsbury (smspillaz)]

> Nvidia here and I can confirm MacSlow's findings.

Damn, ok. Their driver is broken :( I will have to work around it.

[Sam Spilsbury (smspillaz)]

Noted: the driver is not carrying over attributes when set using glPushAttrib (GL_CURRENT_BIT), Jay says that they should be, and this is what the mesa drivers do, so NVIDIA should know about this.

[Michal Hruby (mhr3)]

I can confirm that it properly repaints now, can't test multiple monitors though.

[Jason Smith (jassmith)]

+1

review: Approve

[Sam Spilsbury (smspillaz)]

Can someone with fglrx test this ?

[Gord Allott (gordallott)]

On 11/10/11 12:18, Sam Spilsbury wrote:
> Noted: the driver is not carrying over attributes when set using glPushAttrib (GL_CURRENT_BIT), Jay says that they should be, and this is what the mesa drivers do, so NVIDIA should know about this.

merge approved

--
Gordon Allott
Canonical Ltd.
27 Floor, Millbank Tower
London SW1P 4QP
www.canonical.com

[Sam Spilsbury (smspillaz)]

Testcase is to make sure that the screen actually redraws the way you'd expect it to. Bonus points if you can

 1) Test with multiple monitors to make sure the blur is correct on both
 2) No blur offsets
 3) No "flickering" when switching workspaces using expo
 4) No crashes when you hotplug a monitor on intel.

There is no unit test.

[Sam Spilsbury (smspillaz)]

*cough* *cough* someone test this on fglrx *cough*

[Tim Penhey (thumper)]

Instead of
  uScreen->_fbo = UnityFBO::Ptr (new UnityFBO (geometry));
you can go
  uScreen->_fbo.reset(new UnityFBO(geometry));

Saves a little typing (and it is more efficient in behaviour),

  UnityFBO::UnityFBO (CompRect geometry)
should be
  UnityFBO::UnityFBO(CompRect const& geometry)

Avoids an extra copy.

[Jason Smith (jassmith)]

This requires testing for merge

review: Needs Fixing

[Mirco Müller (macslow)]

I checked this again. It works on nvidia (binary driver) now. Still unable to test it on any ATI-gfx-card, due to lack of hardware.

Regarding the missing unit-test... you could at least add a manual-test derived from your bullet-point list you posted in the comments. Than I'd be ok to give it a +1 when we found someone to test it successfully in a ATI-gfx-card.

[Jason Smith (jassmith)]

Works like the other oem branch afaict, no merge conflicts after time. I say approve :)

review: Approve

[Sam Spilsbury (smspillaz)]

standalone-clients/TestScreenEffectFramebufferObject is a unit test in this case. It isn't automated, but it should how how the code works and you can test every possible case it hits.

[Daniel van Vugt (vanvugt)]

For the record, this proposal also contains the fixes for bug 861061 and bug 880707. This is because Sam's branches copied the fix from lp:~vanvugt/unity/fix-861061-trunk

=== modified file 'plugins/unityshell/src/BackgroundEffectHelper.cpp'
--- plugins/unityshell/src/BackgroundEffectHelper.cpp	2011-09-28 05:19:39 +0000
+++ plugins/unityshell/src/BackgroundEffectHelper.cpp	2012-01-05 02:50:45 +0000
@@ -85,7 +85,20 @@
 bool BackgroundEffectHelper::HasEnabledHelpers()
 {
   for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
+  {
     if (bg_effect_helper->enabled)
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool BackgroundEffectHelper::HasDirtyHelpers()
+{
+  for (BackgroundEffectHelper * bg_effect_helper : registered_list_)
+    if (bg_effect_helper->enabled && bg_effect_helper->cache_dirty)
       return true;
 
   return false;

=== modified file 'plugins/unityshell/src/BackgroundEffectHelper.h'
--- plugins/unityshell/src/BackgroundEffectHelper.h	2011-10-19 22:13:57 +0000
+++ plugins/unityshell/src/BackgroundEffectHelper.h	2012-01-05 02:50:45 +0000
@@ -53,7 +53,7 @@
   void DirtyCache();
 
   static void ProcessDamage(nux::Geometry geo);
-
+  static bool HasDirtyHelpers();
   static bool HasEnabledHelpers();
 
   static nux::Property<unity::BlurType> blur_type;

=== modified file 'plugins/unityshell/src/PanelView.cpp'
--- plugins/unityshell/src/PanelView.cpp	2011-12-19 20:20:22 +0000
+++ plugins/unityshell/src/PanelView.cpp	2012-01-05 02:50:45 +0000
@@ -616,8 +616,7 @@
 
   _opacity = opacity;
 
-  if (_opacity < 1.0f && !_dash_is_open)
-    bg_effect_helper_.enabled = false;
+  bg_effect_helper_.enabled = (_opacity < 1.0f || _dash_is_open);
 
   ForceUpdateBackground();
 }

=== added file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-01-05 02:50:45 +0000
@@ -0,0 +1,234 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ScreenEffectFramebufferObject.h"
+#include "BackgroundEffectHelper.h"
+#include <NuxCore/Logger.h>
+#include <dlfcn.h>
+
+namespace
+{
+  nux::logging::Logger logger ("unity.screeneffectframebufferobject");
+}
+
+void unity::ScreenEffectFramebufferObject::paint (const nux::Geometry &output)
+{
+  /* Draw the bit of the relevant framebuffer for each output */
+
+  glPushAttrib (GL_VIEWPORT_BIT);
+  glViewport (0, mScreenSize.height - (output.y + output.height), mScreenSize.width, mScreenSize.height);
+
+  if (mFBTexture)
+  {
+    glEnable (GL_TEXTURE_2D);
+    activeTexture (GL_TEXTURE0_ARB);
+    glBindTexture (GL_TEXTURE_2D, mFBTexture);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    glPushAttrib (GL_SCISSOR_BIT);
+    glEnable (GL_SCISSOR_TEST);
+
+    glScissor (output.x, mScreenSize.height - (output.y + output.height),
+	       output.width, output.height);
+
+    /* FIXME: This needs to be GL_TRIANGLE_STRIP */
+    glBegin (GL_QUADS);
+    glTexCoord2f (0, 1);
+    glVertex2i   (mGeometry.x, mGeometry.y);
+    glTexCoord2f (0, 0);
+    glVertex2i   (mGeometry.x, mGeometry.y + mGeometry.height);
+    glTexCoord2f (1, 0);
+    glVertex2i   (mGeometry.x + mGeometry.width, mGeometry.y + mGeometry.height);
+    glTexCoord2f (1, 1);
+    glVertex2i   (mGeometry.x + mGeometry.width, mGeometry.y);
+    glEnd ();
+
+    activeTexture (GL_TEXTURE0_ARB);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glBindTexture (GL_TEXTURE_2D, 0);
+    glDisable (GL_TEXTURE_2D);
+    glPopAttrib ();
+  }
+  glPopAttrib ();
+}
+
+void unity::ScreenEffectFramebufferObject::onScreenSizeChanged(const nux::Geometry& screenSize)
+{
+  mScreenSize = screenSize;
+}
+
+
+void unity::ScreenEffectFramebufferObject::unbind ()
+{
+  if (!mBoundCnt)
+    return;
+
+  mBoundCnt--;
+
+  (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
+
+  glDrawBuffer (GL_BACK);
+  glReadBuffer (GL_BACK);
+
+  /* Matches the viewport set we did in ::bind () */
+  glPopAttrib ();
+
+}
+
+bool unity::ScreenEffectFramebufferObject::status ()
+{
+  return mFboStatus;
+}
+
+void unity::ScreenEffectFramebufferObject::bind (const nux::Geometry &output)
+{
+  if (!BackgroundEffectHelper::HasDirtyHelpers())
+    return;
+
+  /* Clear the error bit */
+  glGetError ();
+
+  if (!mFBTexture)
+  {
+    glGenTextures (1, &mFBTexture);
+
+    glBindTexture (GL_TEXTURE_2D, mFBTexture);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, mGeometry.width, mGeometry.height, 0, GL_BGRA,
+#if IMAGE_BYTE_ORDER == MSBFirst
+                 GL_UNSIGNED_INT_8_8_8_8_REV,
+#else
+                 GL_UNSIGNED_BYTE,
+#endif
+                 NULL);
+
+    glBindTexture (GL_TEXTURE_2D, 0);
+
+    if (glGetError () != GL_NO_ERROR)
+    {
+      mFboHandle = 0;
+      mFboStatus = false;
+      return;
+    }
+  }
+
+  (*bindFramebuffer) (GL_FRAMEBUFFER_EXT, mFboHandle);
+
+  (*framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                               GL_TEXTURE_2D, mFBTexture, 0);
+
+  (*framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
+                               GL_TEXTURE_2D, 0, 0);
+
+  /* Ensure that a framebuffer is actually available */
+  if (!mFboStatus)
+  {
+    GLint status = (*checkFramebufferStatus) (GL_DRAW_FRAMEBUFFER);
+
+    if (status != GL_FRAMEBUFFER_COMPLETE)
+    {
+      switch (status)
+      {
+        case GL_FRAMEBUFFER_UNDEFINED:
+          LOG_WARN (logger) <<  "no window";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+          LOG_WARN (logger) <<  "attachment incomplete";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+          LOG_WARN (logger) <<  "no buffers attached to fbo";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+          LOG_WARN (logger) <<  "some attachment in glDrawBuffers doesn't exist in FBO";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+          LOG_WARN (logger) <<  "some attachment in glReadBuffers doesn't exist in FBO";
+          break;
+        case GL_FRAMEBUFFER_UNSUPPORTED:
+          LOG_WARN (logger) <<  "unsupported internal format";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
+          LOG_WARN (logger) <<  "different levels of sampling for each attachment";
+          break;
+        case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
+          LOG_WARN (logger) <<  "number of layers is different";
+          break;
+        default:
+          LOG_WARN (logger) <<  "unable to bind the framebuffer for an unknown reason";
+          break;
+      }
+
+      bindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
+      deleteFramebuffers (1, &mFboHandle);
+
+      glDrawBuffer (GL_BACK);
+      glReadBuffer (GL_BACK);
+
+      mFboHandle = 0;
+
+      mFboStatus = false;
+    }
+    else
+      mFboStatus = true;
+  }
+
+  if (mFboStatus)
+  {
+    glPushAttrib (GL_VIEWPORT_BIT);
+
+    glViewport (output.x,
+	       mScreenSize.height - (output.y + output.height),
+	       output.width,
+	       output.height);
+  }
+
+  mBoundCnt++;
+}
+
+
+unity::ScreenEffectFramebufferObject::ScreenEffectFramebufferObject (GLXGetProcAddressProc p, const nux::Geometry &geom)
+ : getProcAddressGLX (p)
+ , mFboStatus (false)
+ , mFBTexture (0)
+ , mGeometry (geom)
+ , mBoundCnt (0)
+ , mScreenSize (geom)
+{
+  activeTexture = (GLActiveTextureProc) (*getProcAddressGLX) ((GLubyte *) "glActiveTexture");
+  genFramebuffers = (GLGenFramebuffersProc) (*getProcAddressGLX) ((GLubyte *)"glGenFramebuffersEXT");
+  deleteFramebuffers = (GLDeleteFramebuffersProc) (*getProcAddressGLX) ((GLubyte *)"glDeleteFramebuffersEXT");
+  bindFramebuffer = (GLBindFramebufferProc) (*getProcAddressGLX) ((GLubyte *)"glBindFramebufferEXT");
+  checkFramebufferStatus = (GLCheckFramebufferStatusProc) (*getProcAddressGLX) ((GLubyte *) "glCheckFramebufferStatusEXT");
+  framebufferTexture2D = (GLFramebufferTexture2DProc) (*getProcAddressGLX) ((GLubyte *) "glFramebufferTexture2DEXT");
+  
+  (*genFramebuffers) (1, &mFboHandle);
+}
+
+unity::ScreenEffectFramebufferObject::~ScreenEffectFramebufferObject ()
+{
+  (*deleteFramebuffers) (1, &mFboHandle);
+
+  if (mFBTexture)
+    glDeleteTextures (1, &mFBTexture);
+}

=== added file 'plugins/unityshell/src/ScreenEffectFramebufferObject.h'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.h	2012-01-05 02:50:45 +0000
@@ -0,0 +1,87 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#ifndef UNITY_SCREENEFFECT_FRAMEBUFFER_H
+#define UNITY_SCREENEFFECT_FRAMEBUFFER_H
+
+#include <Nux/Nux.h>
+
+namespace unity
+{
+class ScreenEffectFramebufferObject
+{
+public:
+
+  typedef boost::shared_ptr <ScreenEffectFramebufferObject> Ptr;
+  typedef void (*FuncPtr) (void);
+  typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
+
+  ScreenEffectFramebufferObject (GLXGetProcAddressProc, const nux::Geometry &geom);
+  ~ScreenEffectFramebufferObject ();
+
+public:
+
+  void bind (const nux::Geometry &geom);
+  void unbind ();
+
+  bool status ();
+  void paint (const nux::Geometry &geom);
+  bool bound () { return mBoundCnt > 0; }
+
+  GLuint texture () { return mFBTexture; }
+  
+  void onScreenSizeChanged (const nux::Geometry &screenSize);
+
+private:
+
+  FuncPtr getProcAddr (const std::string &);
+
+  typedef void (*GLActiveTextureProc) (GLenum texture);
+  typedef void (*GLGenFramebuffersProc) (GLsizei n,
+                                         GLuint  *framebuffers);
+  typedef void (*GLDeleteFramebuffersProc) (GLsizei n,
+                                            GLuint  *framebuffers);
+  typedef void (*GLBindFramebufferProc) (GLenum target,
+                                         GLuint framebuffer);
+  typedef GLenum (*GLCheckFramebufferStatusProc) (GLenum target);
+  typedef void (*GLFramebufferTexture2DProc) (GLenum target,
+                                              GLenum attachment,
+                                              GLenum textarget,
+                                              GLuint texture,
+                                              GLint  level);
+  
+  GLXGetProcAddressProc getProcAddressGLX;
+  GLActiveTextureProc activeTexture;
+  GLGenFramebuffersProc genFramebuffers;
+  GLDeleteFramebuffersProc deleteFramebuffers;
+  GLBindFramebufferProc bindFramebuffer;
+  GLCheckFramebufferStatusProc checkFramebufferStatus;
+  GLFramebufferTexture2DProc framebufferTexture2D;
+  /* compiz fbo handle that goes through to nux */
+  GLuint   mFboHandle; // actual handle to the framebuffer_ext
+  bool    mFboStatus; // did the framebuffer texture bind succeed
+  GLuint   mFBTexture;
+  nux::Geometry mGeometry;
+  unsigned int mBoundCnt;
+  
+  nux::Geometry mScreenSize;
+};
+} // namespace unity
+
+#endif

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-01-02 20:51:09 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-01-05 02:50:45 +0000
@@ -65,7 +65,6 @@
 /* Set up vtable symbols */
 COMPIZ_PLUGIN_20090315(unityshell, unity::UnityPluginVTable);
 
-
 namespace unity
 {
 using launcher::AbstractLauncherIcon;
@@ -114,7 +113,7 @@
   , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
-  , mActiveFbo (0)
+  , _active_fbo (0)
   , dash_is_open_ (false)
   , grab_index_ (0)
   , painting_tray_ (false)
@@ -227,12 +226,21 @@
      _edge_timeout = optionGetLauncherRevealEdgeTimeout ();
      _in_paint = false;
 
+    void *dlhand = dlopen ("libunityshell.so", RTLD_LAZY);
+
+    if (dlhand)
+    {
+      dlerror ();
+      glXGetProcAddressP = (ScreenEffectFramebufferObject::GLXGetProcAddressProc) dlsym (dlhand, "glXGetProcAddress");
+      if (dlerror () != NULL)
+        glXGetProcAddressP = NULL;
+    }
+
      if (GL::fbo)
      {
-       foreach (CompOutput & o, screen->outputDevs())
-	     uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO(&o));
-
-       uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO(&(screen->fullscreenOutput ())));
+       nux::Geometry geometry (0, 0, screen->width (), screen->height ());
+       uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+       uScreen->_fbo->onScreenSizeChanged (geometry);
      }
 
      optionSetBackgroundColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -451,7 +459,7 @@
 
 void UnityScreen::nuxEpilogue()
 {
-  (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, mActiveFbo);
+  (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, _active_fbo);
 
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
@@ -492,8 +500,6 @@
   if (PluginAdapter::Default()->IsExpoActive())
     return;
 
-  nuxPrologue();
-
   CompOutput* output = _last_output;
   float vc[4];
   float h = 20.0f;
@@ -504,6 +510,9 @@
   float y1 = output->y() + panel_h;
   float x2 = x1 + output->width();
   float y2 = y1 + h;
+  GLMatrix sTransform = GLMatrix ();
+
+  sTransform.toScreenSpace(output, -DEFAULT_Z_CAMERA);
 
   vc[0] = x1;
   vc[1] = x2;
@@ -543,7 +552,6 @@
       glDisable(GL_BLEND);
     }
   }
-  nuxEpilogue();
 }
 
 void
@@ -562,30 +570,35 @@
 {
   CompOutput *output = _last_output;
   Window     tray_xid = panel_controller_->GetTrayXid ();
-  bool       bound = mFbos[output]->bound ();
-
-
-  if (bound)
+
+  bool was_bound = _fbo->bound ();
+  _fbo->unbind ();
+
+  /* Draw the bit of the relevant framebuffer for each output */
+
+  if (was_bound)
   {
-    mFbos[output]->unbind ();
-
-    /* Draw the bit of the relevant framebuffer for each output */
-    mFbos[output]->paint ();
+    GLMatrix sTransform;
+    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
+    glPushMatrix ();
+    glLoadMatrixf (sTransform.getMatrix ());
+    _fbo->paint (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+    glPopMatrix ();
   }
 
-  nuxPrologue();
-
   nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
-  nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(mFbos[output]->texture(),
-  output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
+      nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(_fbo->texture(),
+                                                                       screen->width (), screen->height(), 1, nux::BITFMT_R8G8B8A8);
 
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
 
-  nux::Geometry geo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
+  nux::Geometry geo = nux::Geometry (0, 0, screen->width (), screen->height ());
+  nux::Geometry oGeo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
   BackgroundEffectHelper::monitor_rect_ = geo;
 
+  nuxPrologue();
   _in_paint = true;
-  wt->RenderInterfaceFromForeignCmd (&geo);
+  wt->RenderInterfaceFromForeignCmd (&oGeo);
   _in_paint = false;
   nuxEpilogue();
 
@@ -985,6 +998,10 @@
 {
   bool ret;
 
+  doShellRepaint = true;
+  allowWindowPaint = true;
+  _last_output = output;
+
   /* bind the framebuffer here
    * - it will be unbound and flushed
    *   to the backbuffer when some
@@ -995,11 +1012,7 @@
    *   attempts to bind it will only increment
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
-  mFbos[output]->bind ();
-
-  doShellRepaint = true;
-  allowWindowPaint = true;
-  _last_output = output;
+  _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
@@ -1160,16 +1173,37 @@
   {
     XDamageNotifyEvent *de = (XDamageNotifyEvent *) event;
     CompWindow* w = screen->findWindow (de->drawable);
+    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
+    CompWindow* lastNWindow = screen->findWindow (xwns.back ());
+    bool        processDamage = true;
 
-    if (w and !(w->wmType() & CompWindowTypeDndMask))
+    if (w)
     {
-      nux::Geometry damage (de->area.x, de->area.y, de->area.width, de->area.height);
-
-      CompWindow::Geometry geom = w->geometry ();
-      damage.x += geom.x () + geom.border ();
-      damage.y += geom.y () + geom.border ();
-
-      BackgroundEffectHelper::ProcessDamage(damage);
+      if (!w->overrideRedirect () &&
+          w->isViewable () &&
+          !w->invisible ())
+      {
+
+        for (; lastNWindow != NULL; lastNWindow = lastNWindow->next)
+        {
+          if (lastNWindow == w)
+          {
+            processDamage = false;
+            break;
+          }
+        }
+
+        if (processDamage)
+        {
+          nux::Geometry damage (de->area.x, de->area.y, de->area.width, de->area.height);
+
+          const CompWindow::Geometry &geom = w->geometry ();
+          damage.x += geom.x () + geom.border ();
+          damage.y += geom.y () + geom.border ();
+
+          BackgroundEffectHelper::ProcessDamage(damage);
+        }
+      }
     }
   }
 }
@@ -2164,15 +2198,15 @@
 
 void UnityScreen::Relayout()
 {
+  nux::Geometry geometry (0, 0, screen->width (), screen->height ());
+
   if (!needsRelayout)
     return;
 
   if (GL::fbo)
   {
-    foreach (CompOutput &o, screen->outputDevs ())
-      uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO (&o));
-
-    uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO (&(screen->fullscreenOutput ())));
+    uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
+    uScreen->_fbo->onScreenSizeChanged (geometry);
   }
 
   UScreen *uscreen = UScreen::GetDefault();
@@ -2195,8 +2229,6 @@
 {
   UnityScreen* uScr = reinterpret_cast<UnityScreen*>(data);
 
-  uScreen->mFbos.clear ();
-
   uScr->NeedsRelayout ();
   uScr->Relayout();
   uScr->relayoutSourceId = 0;
@@ -2229,220 +2261,6 @@
   ScheduleRelayout(500);
 }
 
-void UnityFBO::paint ()
-{
-  //CompositeScreen *cScreen = CompositeScreen::get (screen);
-  //unsigned int    mask = cScreen->damageMask ();
-  float texx, texy, texwidth, texheight;
-
-  /* Must be completely unbound before painting */
-  if (mBoundCnt)
-    return;
-
-  /* Draw the bit of the relevant framebuffer for each output */
-  GLMatrix transform;
-
-  glViewport (output->x (), screen->height () - output->y2 (), output->width (), output->height ());
-  GLScreen::get (screen)->clearOutput (output, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-  transform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
-  glPushMatrix ();
-  glLoadMatrixf (transform.getMatrix ());
-
-  /* Note that texcoords here are normalized, so it's just (0,0)-(1,1) */
-  texx = 0.0;
-  texy = 0.0;
-  texwidth = 1.0f;
-  texheight = 1.0f;
-
-  if (mFBTexture)
-  {
-    glEnable (GL_TEXTURE_2D);
-    GL::activeTexture (GL_TEXTURE0_ARB);
-    glBindTexture (GL_TEXTURE_2D, mFBTexture);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-    glPushAttrib (GL_SCISSOR_BIT);
-    glEnable (GL_SCISSOR_TEST);
-
-    glScissor (output->x1 (), screen->height () - output->y2 (),
-               output->width (), output->height ());
-
-    /* FIXME: This needs to be GL_TRIANGLE_STRIP */
-    glBegin (GL_QUADS);
-    glTexCoord2f (texx, texy + texheight);
-    glVertex2i   (output->x1 (), output->y1 ());
-    glTexCoord2f (texx, texy);
-    glVertex2i   (output->x1 (), output->y2 ());
-    glTexCoord2f (texx + texwidth, texy);
-    glVertex2i   (output->x2 (), output->y2 ());
-    glTexCoord2f (texx + texwidth, texy + texheight);
-    glVertex2i   (output->x2 (),  output->y1 ());
-    glEnd ();
-
-    GL::activeTexture (GL_TEXTURE0_ARB);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glBindTexture (GL_TEXTURE_2D, 0);
-    glEnable (GL_TEXTURE_2D);
-
-    glDisable (GL_SCISSOR_TEST);
-    glPopAttrib ();
-  }
-
-  glPopMatrix();
-}
-
-void UnityFBO::unbind ()
-{
-  mBoundCnt--;
-
-  if (mBoundCnt)
-    return;
-
-  uScreen->setActiveFbo (0);
-  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
-
-  glDrawBuffer (GL_BACK);
-  glReadBuffer (GL_BACK);
-
-}
-
-bool UnityFBO::bound ()
-{
-  return mBoundCnt > 0;
-}
-
-bool UnityFBO::status ()
-{
-  return mFboStatus;
-}
-
-void UnityFBO::bind ()
-{
-  if (mBoundCnt)
-  {
-    mBoundCnt++;
-    return;
-  }
-
-  if (!mFBTexture)
-  {
-    glGenTextures (1, &mFBTexture);
-
-    glBindTexture (GL_TEXTURE_2D, mFBTexture);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, output->width(), output->height(), 0, GL_BGRA,
-#if IMAGE_BYTE_ORDER == MSBFirst
-                 GL_UNSIGNED_INT_8_8_8_8_REV,
-#else
-                 GL_UNSIGNED_BYTE,
-#endif
-                 NULL);
-
-    glBindTexture (GL_TEXTURE_2D, 0);
-  }
-
-  glGetError ();
-
-  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, mFboHandle);
-
-  (*GL::framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                               GL_TEXTURE_2D, mFBTexture, 0);
-
-  (*GL::framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
-                               GL_TEXTURE_2D, 0, 0);
-
-  /* Ensure that a framebuffer is actually available */
-  if (!mFboStatus)
-  {
-    GLint status = (*GL::checkFramebufferStatus) (GL_DRAW_FRAMEBUFFER);
-
-    if (status != GL_FRAMEBUFFER_COMPLETE)
-    {
-      switch (status)
-      {
-        case GL_FRAMEBUFFER_UNDEFINED:
-          compLogMessage ("unity", CompLogLevelWarn, "no window");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-          compLogMessage ("unity", CompLogLevelWarn, "attachment incomplete");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-          compLogMessage ("unity", CompLogLevelWarn, "no buffers attached to fbo");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
-          compLogMessage ("unity", CompLogLevelWarn, "some attachment in glDrawBuffers doesn't exist in FBO");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
-          compLogMessage ("unity", CompLogLevelWarn, "some attachment in glReadBuffers doesn't exist in FBO");
-          break;
-        case GL_FRAMEBUFFER_UNSUPPORTED:
-          compLogMessage ("unity", CompLogLevelWarn, "unsupported internal format");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
-          compLogMessage ("unity", CompLogLevelWarn, "different levels of sampling for each attachment");
-          break;
-        case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
-          compLogMessage ("unity", CompLogLevelWarn, "number of layers is different");
-          break;
-        default:
-          compLogMessage ("unity", CompLogLevelWarn, "unable to bind the framebuffer for an unknown reason");
-          break;
-      }
-
-      GL::bindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
-      GL::deleteFramebuffers (1, &mFboHandle);
-
-      glDrawBuffer (GL_BACK);
-      glReadBuffer (GL_BACK);
-
-      mFboHandle = 0;
-
-      mFboStatus = false;
-      uScreen->setActiveFbo (0);
-    }
-    else
-      mFboStatus = true;
-  }
-
-  if (mFboStatus)
-  {
-    uScreen->setActiveFbo (mFboHandle);
-
-    glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
-    glReadBuffer (GL_COLOR_ATTACHMENT0_EXT);
-
-    glViewport (0,
-               0,
-               output->width(),
-               output->height());
-
-    mBoundCnt++;
-  }
-}
-
-UnityFBO::UnityFBO (CompOutput *o)
- : mFboStatus (false)
- , mFBTexture (0)
- , output (o)
- , mBoundCnt (0)
-{
-  (*GL::genFramebuffers) (1, &mFboHandle);
-}
-
-UnityFBO::~UnityFBO ()
-{
-  (*GL::deleteFramebuffers) (1, &mFboHandle);
-
-  if (mFBTexture)
-    glDeleteTextures (1, &mFBTexture);
-}
-
 void UnityScreen::OnDashRealized ()
 {
   /* stack any windows named "onboard" above us */

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2011-12-15 07:08:41 +0000
+++ plugins/unityshell/src/unityshell.h	2012-01-05 02:50:45 +0000
@@ -47,47 +47,19 @@
 #include "DebugDBusInterface.h"
 #include "SwitcherController.h"
 #include "UBusWrapper.h"
+#include "ScreenEffectFramebufferObject.h"
 
 #include "compizminimizedwindowhandler.h"
 #include "BGHash.h"
 #include <compiztoolbox/compiztoolbox.h>
+#include <dlfcn.h>
 
 namespace unity
 {
 
-class UnityFBO
-{
-public:
-
-  typedef boost::shared_ptr <UnityFBO> Ptr;
-
-  UnityFBO (CompOutput *o);
-  ~UnityFBO ();
-
-public:
-
-  void bind ();
-  void unbind ();
-
-  bool status ();
-  bool bound ();
-  void paint ();
-
-  GLuint texture () { return mFBTexture; }
-
-private:
-
-  /* compiz fbo handle that goes through to nux */
-  GLuint   mFboHandle; // actual handle to the framebuffer_ext
-  bool    mFboStatus; // did the framebuffer texture bind succeed
-  GLuint   mFBTexture;
-  CompOutput *output;
-  unsigned int mBoundCnt;
-};
-
 class UnityShowdesktopHandler
 {
-public:
+ public:
 
   UnityShowdesktopHandler (CompWindow *w);
   ~UnityShowdesktopHandler ();
@@ -234,8 +206,6 @@
   void NeedsRelayout();
   void ScheduleRelayout(guint timeout);
 
-  void setActiveFbo (GLuint fbo) { mActiveFbo = fbo; }
-
   bool forcePaintOnTop ();
 
 protected:
@@ -320,8 +290,8 @@
 
   unity::BGHash _bghash;
 
-  std::map <CompOutput *, UnityFBO::Ptr> mFbos;
-  GLuint                                 mActiveFbo;
+  ScreenEffectFramebufferObject::Ptr _fbo;
+  GLuint                             _active_fbo;
 
   bool   queryForShader ();
 
@@ -332,6 +302,8 @@
   bool                   painting_tray_;
   unsigned int           tray_paint_mask_;
 
+  ScreenEffectFramebufferObject::GLXGetProcAddressProc glXGetProcAddressP;
+
   friend class UnityWindow;
 };
 

=== modified file 'standalone-clients/CMakeLists.txt'
--- standalone-clients/CMakeLists.txt	2011-12-14 01:47:53 +0000
+++ standalone-clients/CMakeLists.txt	2012-01-05 02:50:45 +0000
@@ -26,13 +26,13 @@
      )
 add_definitions (${CFLAGS})
 
-set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION} -lm")
+set (LIBS ${TEST_UNIT_DEPS_LIBRARIES} "-lunity-core-${UNITY_API_VERSION} -lm -lGL -lGLU")
 link_libraries (${LIBS})
 
 set (LIB_PATHS ${TEST_UNIT_DEPS_LIBRARY_DIRS})
 link_directories (${CMAKE_BINARY_DIR}/UnityCore ${LIB_PATHS})
 
-include_directories (. .. ../services ../UnityCore ${UNITY_SRC} ${CMAKE_BINARY_DIR})
+include_directories (. .. ../services ../UnityCore ${UNITY_SRC} ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
 
 # We can't have convenience libs so we need to rebuild with what we need
 # Please keep actual test files alphabetically at top and then files
@@ -452,6 +452,20 @@
                )
 add_dependencies (bg-hash unity-core-${UNITY_API_VERSION})
 
+find_package (OpenGL)
+
+include_directories (${OPENGL_gl_INCDIRS})
+add_library (glfuncloader SHARED
+	     ${CMAKE_CURRENT_SOURCE_DIR}/GLFuncLoader.cpp)
+target_link_libraries (glfuncloader dl ${OPENGL_gl_LIBRARY})
+add_executable (screen-effect-fbo
+		TestScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/ScreenEffectFramebufferObject.cpp
+		${UNITY_SRC}/BackgroundEffectHelper.cpp)
+
+target_link_libraries (screen-effect-fbo glfuncloader ${OPENGL_gl_LIBRARY})
+add_dependencies (screen-effect-fbo ${UNITY_API_VERSION})
+
 
 # Custom target to make all the other targets here, add your test to this list
 add_custom_target(standalone-clients DEPENDS dash panel launcher switcher keyutil quicklist quicklist-visuals filters filter-bar preview-applicaiton preview-generic preview-music result-view dash-style bg-hash)

=== added file 'standalone-clients/GLFuncLoader.cpp'
--- standalone-clients/GLFuncLoader.cpp	1970-01-01 00:00:00 +0000
+++ standalone-clients/GLFuncLoader.cpp	2012-01-05 02:50:45 +0000
@@ -0,0 +1,51 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "GLFuncLoader.h"
+#include <dlfcn.h>
+
+unity::GLLoader::FuncPtr unity::GLLoader::getProcAddr(const std::string &name)
+{
+  static void *dlhand = NULL;
+  FuncPtr funcPtr = NULL;
+
+  glGetError ();
+
+  if (!funcPtr)
+  {
+    if (!dlhand)
+      dlhand = dlopen ("libglfuncloader.so", RTLD_LAZY);
+
+    char *error =  dlerror ();
+
+    if (dlhand)
+    {
+      dlerror ();
+      funcPtr = (FuncPtr) dlsym (dlhand, name.c_str ());
+
+      error = dlerror ();
+      if (error != NULL)
+        funcPtr = NULL;
+    }
+  }
+
+  return funcPtr;
+}
+
+

=== added file 'standalone-clients/GLFuncLoader.h'
--- standalone-clients/GLFuncLoader.h	1970-01-01 00:00:00 +0000
+++ standalone-clients/GLFuncLoader.h	2012-01-05 02:50:45 +0000
@@ -0,0 +1,33 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include <string>
+#include <GL/gl.h>
+#include <GL/glx.h>
+
+namespace unity
+{
+namespace GLLoader
+{
+typedef void (*FuncPtr) (void);
+typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
+
+FuncPtr getProcAddr(const std::string &name);
+}
+}

=== added file 'standalone-clients/TestScreenEffectFramebufferObject.cpp'
--- standalone-clients/TestScreenEffectFramebufferObject.cpp	1970-01-01 00:00:00 +0000
+++ standalone-clients/TestScreenEffectFramebufferObject.cpp	2012-01-05 02:50:45 +0000
@@ -0,0 +1,670 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/* Compiz unity plugin
+ * unity.h
+ *
+ * Copyright (c) 2010-11 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Authored By: Sam Spilsbury <[e-mail]>
+ */
+
+#include "ScreenEffectFramebufferObject.h"
+#include "BackgroundEffectHelper.h"
+#include "GLFuncLoader.h"
+#include <Nux/Nux.h>
+#include <Nux/VLayout.h>
+#include <Nux/View.h>
+#include <Nux/BaseWindow.h>
+#include <Nux/WindowCompositor.h>
+#include <NuxCore/Logger.h>
+#include <NuxCore/Object.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <dlfcn.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <cmath>
+
+using namespace unity::GLLoader;
+
+namespace
+{
+  nux::logging::Logger logger ("unity.test-screeneffectframebufferobject");
+
+  const static int attributes[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                                    GLX_X_RENDERABLE, True,
+                                    GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+                                    GLX_DOUBLEBUFFER, True,
+                                    GLX_RED_SIZE, 8,
+                                    GLX_GREEN_SIZE, 8,
+                                    GLX_BLUE_SIZE, 8, 0};
+}
+
+namespace GLFuncs
+{
+  GLXGetProcAddressProc           glXGetProcAddressP;
+  PFNGLXCHOOSEFBCONFIGPROC        glXChooseFBConfigP;
+  PFNGLXGETVISUALFROMFBCONFIGPROC glXGetVisualFromFBConfigP;
+  PFNGLXCREATEWINDOWPROC          glXCreateWindowP;
+  PFNGLXDESTROYWINDOWPROC         glXDestroyWindowP;
+  PFNGLXMAKECONTEXTCURRENTPROC    glXMakeContextCurrentP;
+
+  void init ()
+  {
+    glXGetProcAddressP = (GLXGetProcAddressProc) getProcAddr ("glXGetProcAddress");
+    glXChooseFBConfigP = (PFNGLXCHOOSEFBCONFIGPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXChooseFBConfig");
+    glXGetVisualFromFBConfigP = (PFNGLXGETVISUALFROMFBCONFIGPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXGetVisualFromFBConfig");
+    glXCreateWindowP = (PFNGLXCREATEWINDOWPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXCreateWindow");
+    glXMakeContextCurrentP = (PFNGLXMAKECONTEXTCURRENTPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXMakeContextCurrent");
+    glXDestroyWindowP      = (PFNGLXDESTROYWINDOWPROC) (*glXGetProcAddressP) ((const GLubyte *) "glXDestroyWindow");
+  }
+}
+
+class EffectView :
+  public nux::View
+{
+public:
+  EffectView (NUX_FILE_LINE_PROTO);
+  virtual ~EffectView ();
+
+  void Draw (nux::GraphicsEngine &context, bool force) { return; };
+  void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
+private:
+  BackgroundEffectHelper bg_effect_helper_;
+};
+
+class Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Shape> Ptr;
+
+    Shape ();
+    virtual ~Shape ();
+
+    float rotation () { return mRotation; }
+
+    void draw (unsigned int width, unsigned int height) { glDraw (width, height); }
+    void rotate () { applyRotation (); }
+
+  protected:
+
+    float mRotation;
+
+    virtual void glDraw (unsigned int width, unsigned int height) = 0;
+    virtual void applyRotation () = 0;
+    virtual void getRotationAxes (float &x, float &y, float &z) = 0;
+};
+
+Shape::Shape () :
+ mRotation (0.0f)
+{
+}
+
+Shape::~Shape ()
+{
+}
+
+class Triangle :
+  public Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Triangle> Ptr;
+
+  protected:
+
+    void glDraw (unsigned int width, unsigned int height);
+    void applyRotation () { mRotation += 5.0f; }
+    void getRotationAxes (float &x, float &y, float &z) { x = 0.0f; y = 1.0f; z = 0.0f; }
+};
+
+void
+Triangle::glDraw (unsigned int width, unsigned int height)
+{
+  glBegin(GL_TRIANGLES);
+      glColor3f(1.0f, 0.0f, 0.0f);
+      glVertex3f(width / 4, height, 0.0f);
+      glColor3f(0.0f, 1.0f, 0.0f);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glColor3f(0.0f, 0.0f, 1.0f);
+      glVertex3f(width / 2, 0.0f, 0.0f);
+  glEnd();
+}
+
+class Square :
+  public Shape
+{
+  public:
+
+    typedef boost::shared_ptr <Square> Ptr;
+
+  protected:
+
+    void glDraw (unsigned int width, unsigned int height);
+    void applyRotation () { mRotation -= 2.5f; }
+    void getRotationAxes (float &x, float &y, float &z) { x = 1.0f; y = 0.0f; z = 0.0f; }
+    
+};
+
+void
+Square::glDraw (unsigned int width, unsigned int height)
+{
+  glBegin(GL_QUADS);
+    glColor3f(sin (rotation () / 100.0f), -sin (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width / 2, height, 0.0f);
+    glColor3f(-sin (rotation () / 100.0f), sin (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width, height, 0.0f);
+    glColor3f(sin (rotation () / 100.0f), sin (rotation () / 100.0f), sin (rotation () / 100.0f));
+    glVertex3f(width, 0.0f, 0.0f);
+    glColor3f(-sin (rotation () / 100.0f), cos (rotation () / 100.0f), cos (rotation () / 100.0f));
+    glVertex3f(width / 2, 0.0f, 0.0f);
+  glEnd();
+}
+
+class BaseContext
+{
+  public:
+
+    BaseContext (Display *);
+    ~BaseContext ();
+
+    void run ();
+
+  protected:
+
+    bool eventHandler ();
+    bool paintDispatch ();
+
+    enum class ModifierApplication
+    {
+      Square,
+      Triangle,
+      Both
+    };
+
+    void nextWindowPosition ();
+    void nextShapeRotation ();
+    void setupContextForSize (unsigned int width,
+                              unsigned int height);
+    void drawShape (const Shape::Ptr &) {};
+
+  private:
+
+    static gboolean onNewEvents (GIOChannel   *channel,
+                                 GIOCondition condition,
+                                 gpointer     data);
+
+    static gboolean onPaintTimeout (gpointer data);
+
+    static void onWindowThreadCreation (nux::NThread *thread, void *d);
+
+    Display                                   *mDisplay;
+    Window                                    mWindow;
+    Colormap                                  mColormap;
+    nux::WindowThread                         *mWindowThread;
+    nux::View                                 *mRootView;
+    unity::ScreenEffectFramebufferObject::Ptr mFbo;
+    GLXWindow                                 mGlxWindow;
+    GLXContext                                mContext;
+    ModifierApplication                       mRotating;
+    ModifierApplication                       mBlur;
+    unsigned int                              mWidth;
+    unsigned int                              mHeight;
+    bool                                      mNuxReady;
+    Shape::Ptr                                mTriangle;
+    Shape::Ptr                                mSquare;
+};
+
+BaseContext::BaseContext (Display *display) :
+  mDisplay (display),
+  mWindowThread (NULL),
+  mRotating (ModifierApplication::Both),
+  mBlur (ModifierApplication::Both),
+  mWidth (640),
+  mHeight (480),
+  mNuxReady (false),
+  mTriangle  (new Triangle ()),
+  mSquare (new Square ())
+{
+  int            numFBConfig = 0;  
+  GLXFBConfig    *fbConfigs = (*GLFuncs::glXChooseFBConfigP) (mDisplay,
+                                                              DefaultScreen (mDisplay),
+                                                              attributes,
+                                                              &numFBConfig);
+  XVisualInfo    *visinfo = (*GLFuncs::glXGetVisualFromFBConfigP) (mDisplay,
+                                                                   fbConfigs[0]);
+
+  mContext = glXCreateContext (mDisplay, visinfo, 0, GL_TRUE);
+  mColormap = XCreateColormap (mDisplay,
+                               DefaultRootWindow (mDisplay),
+                               visinfo->visual,
+                               AllocNone);
+
+  XSetWindowAttributes wa;
+
+  wa.colormap = mColormap;
+  wa.border_pixel = 0;
+  wa.event_mask = StructureNotifyMask | KeyPressMask | ExposureMask;
+
+  mWindow = XCreateWindow (mDisplay, DefaultRootWindow (mDisplay),
+                           0, 0, mWidth, mHeight, 0, visinfo->depth, InputOutput,
+                           visinfo->visual, CWColormap | CWEventMask | CWBorderPixel,
+                           &wa);
+
+  mGlxWindow = (*GLFuncs::glXCreateWindowP) (mDisplay, fbConfigs[0], mWindow, NULL);
+
+  XStoreName (mDisplay, mWindow, "F1: Toggle Effect, F2: Rotation, F3: Effect");
+  XMapWindow (mDisplay, mWindow);
+
+  bool ready = false;
+
+  do
+  {
+    XEvent ev;
+    XNextEvent (mDisplay, &ev);
+    switch (ev.type)
+    {
+      case MapNotify:
+      case ConfigureNotify:
+      case Expose:
+        ready = true;
+        break;
+      default:
+        break;
+    }
+
+  } while (!ready);
+
+  (*GLFuncs::glXMakeContextCurrentP) (mDisplay, mGlxWindow, mGlxWindow, mContext);
+
+  setupContextForSize (mWidth, mHeight);
+}
+
+void
+BaseContext::run ()
+{
+  GIOChannel        *channel;
+  mWindowThread = nux::CreateFromForeignWindow (mWindow,
+                                                mContext,
+                                                &BaseContext::onWindowThreadCreation,
+                                                (void *) this);
+
+  mWindowThread->Run(NULL);
+
+  while (!mNuxReady);
+  g_timeout_add (128, &BaseContext::onPaintTimeout, (gpointer) this);
+
+  channel = g_io_channel_unix_new (ConnectionNumber (mDisplay));
+
+  g_io_add_watch (channel, (GIOCondition) (G_IO_IN | G_IO_HUP | G_IO_ERR),
+                  &BaseContext::onNewEvents, (gpointer) this);
+  gtk_main ();
+}
+
+BaseContext::~BaseContext ()
+{
+  delete mWindowThread;
+
+  (*GLFuncs::glXMakeContextCurrentP) (mDisplay, None, None, mContext);
+  glXDestroyContext (mDisplay, mContext);
+  (*GLFuncs::glXDestroyWindowP) (mDisplay, mGlxWindow);
+
+  XFreeColormap (mDisplay, mColormap);
+  XDestroyWindow (mDisplay, mWindow);
+}
+
+void
+BaseContext::setupContextForSize (unsigned int width,
+                                  unsigned int height)
+{
+  mWidth = width;
+  mHeight = height;
+
+  glViewport(0, 0, width, height);
+  glDrawBuffer (GL_BACK);
+  glReadBuffer (GL_BACK);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  gluPerspective(60.0f, 1.0f, 0.1f, 100.0f);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity ();
+  glClearColor (1, 1, 1, 1);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glXSwapBuffers (mDisplay, mGlxWindow);
+
+  if (mFbo)
+    mFbo.reset (new unity::ScreenEffectFramebufferObject (GLFuncs::glXGetProcAddressP, nux::Geometry (0, 0, mWidth, mHeight)));
+
+  if (mRootView && mNuxReady)
+  {
+    switch (mBlur)
+    {
+      case ModifierApplication::Both:
+        mRootView->SetGeometry (nux::Geometry (0, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Triangle:
+        mRootView->SetGeometry (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Square:
+        mRootView->SetGeometry (nux::Geometry (0, 0, mWidth, mHeight));
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+bool
+BaseContext::eventHandler ()
+{
+  XEvent event;
+  XEvent *ev = &event;
+
+  XNextEvent (mDisplay, &event);
+
+  switch (ev->type)
+  {
+    case KeyPress:
+      if (XLookupKeysym (&ev->xkey, 0) == XK_Escape)
+        return false;
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F1)
+      {
+        if (!mFbo)
+        {
+          BackgroundEffectHelper::blur_type = unity::BLUR_ACTIVE;
+          mFbo.reset (new unity::ScreenEffectFramebufferObject (GLFuncs::glXGetProcAddressP, nux::Geometry (0, 0, mWidth, mHeight)));
+        }
+        else
+        {
+          BackgroundEffectHelper::blur_type = unity::BLUR_NONE;
+          mFbo.reset ();
+        }
+      }
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F2)
+        nextShapeRotation ();
+      else if (XLookupKeysym (&ev->xkey, 0) == XK_F3)
+        nextWindowPosition ();
+      break;
+    case ConfigureNotify:
+      setupContextForSize (ev->xconfigure.width, ev->xconfigure.height);
+    default:
+      break;
+  }
+
+  return true;
+}
+
+gboolean
+BaseContext::onNewEvents (GIOChannel   *channel,
+                          GIOCondition condition,
+                          gpointer     data)
+{
+  BaseContext *self = static_cast <BaseContext *> (data);
+  gboolean    keep_going = TRUE;
+
+  if (condition & G_IO_IN)
+  {
+    if (self->eventHandler ())
+      return TRUE;
+    else
+      return FALSE;
+  }
+
+  return TRUE;
+}
+
+gboolean
+BaseContext::onPaintTimeout (gpointer data)
+{
+  BaseContext *self = static_cast <BaseContext *> (data);
+
+  if (self->paintDispatch ())
+    return TRUE;
+
+  return FALSE;
+}
+
+void
+BaseContext::nextShapeRotation ()
+{
+  switch (mRotating)
+  {
+    case ModifierApplication::Both:
+      mRotating = ModifierApplication::Triangle;
+      break;
+    case ModifierApplication::Triangle:
+      mRotating = ModifierApplication::Square;
+      break;
+    case ModifierApplication::Square:
+      mRotating = ModifierApplication::Both;
+      break;
+    default:
+      break;
+  }
+}
+
+void
+BaseContext::nextWindowPosition ()
+{
+  switch (mBlur)
+  {
+    case ModifierApplication::Both:
+      mBlur = ModifierApplication::Triangle;
+      mRootView->SetGeometry (nux::Geometry (0, 0, mWidth / 2, mHeight));
+      break;
+    case ModifierApplication::Triangle:
+      mBlur = ModifierApplication::Square;
+      mRootView->SetGeometry (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+      break;
+    case ModifierApplication::Square:
+      mBlur = ModifierApplication::Both;
+      mRootView->SetGeometry (nux::Geometry (0, 0, mWidth, mHeight));
+      break;
+    default:
+      break;
+  }
+}
+
+EffectView::EffectView (NUX_FILE_LINE_DECL)
+  : View (NUX_FILE_LINE_PARAM)
+{
+  bg_effect_helper_.owner = this;
+}
+
+EffectView::~EffectView ()
+{
+}
+
+void EffectView::DrawContent (nux::GraphicsEngine &GfxContext, bool force_draw)
+{
+  nux::Geometry base = GetGeometry();
+  GfxContext.PushClippingRectangle(base);
+  nux::Geometry blur_geo (base.x, base.y, base.width, base.height);
+
+  if (BackgroundEffectHelper::blur_type == unity::BLUR_ACTIVE)
+  {
+    bg_effect_helper_.enabled = true;
+
+    auto blur_texture = bg_effect_helper_.GetBlurRegion(blur_geo);
+
+    if (blur_texture.IsValid ())
+    {
+      nux::TexCoordXForm texxform_blur_bg;
+      texxform_blur_bg.flip_v_coord = true;
+      texxform_blur_bg.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
+      texxform_blur_bg.uoffset = ((float) base.x) / (base.width);
+      texxform_blur_bg.voffset = ((float) base.y) / (base.height);
+
+      nux::ROPConfig rop;
+      rop.Blend = false;
+      rop.SrcBlend = GL_ONE;
+      rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+      gPainter.PushDrawTextureLayer(GfxContext, base,
+                                    blur_texture,
+                                    texxform_blur_bg,
+                                    nux::color::White,
+                                    true,
+                                    rop);
+    }
+  }
+  else
+    bg_effect_helper_.enabled = false;
+  GfxContext.PopClippingRectangle();
+}
+
+bool
+BaseContext::paintDispatch ()
+{
+  if (mFbo)
+  {
+    switch (mRotating)
+    {
+      case ModifierApplication::Both:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (0, 0, mWidth, mHeight));
+        break;
+      case ModifierApplication::Triangle:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (0, 0, mWidth / 2, mHeight));
+        break;
+      case ModifierApplication::Square:
+        BackgroundEffectHelper::ProcessDamage (nux::Geometry (mWidth / 2, 0, mWidth / 2, mHeight));
+        break;
+    }
+
+    mFbo->bind (nux::Geometry (0, 0, mWidth, mHeight));
+
+    if (!mFbo->status ())
+      LOG_INFO (logger) << "FBO not ok!";
+  }
+
+  glClearColor (1, 1, 1, 1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glPushMatrix ();
+  glLoadIdentity();
+  glTranslatef(-0.5f, -0.5f, -0.866025404f);
+  glScalef (1.0f / mWidth, 1.0f / mHeight, 0.0f);
+  glTranslatef(mWidth * 0.25, 0, 0);
+  glRotatef(mTriangle->rotation (), 0.0f, 1.0f, 0.0f);
+  glTranslatef(-(mWidth * 0.25), 0, 0);
+
+  mTriangle->draw (mWidth, mHeight);
+
+  glLoadIdentity();
+  glTranslatef(-0.5f, -0.5f, -0.866025404f);
+  glScalef (1.0f / mWidth, 1.0f / mHeight, 0.0f);
+  glTranslatef(mWidth * 0.75, 0, 0);
+  glRotatef(mSquare->rotation (), 0.0f, 1.0f, 0.0f);
+  glTranslatef(-(mWidth * 0.75), 0, 0);
+
+  mSquare->draw (mWidth, mHeight);
+
+  glColor4f (1.0f, 1.0f, 1.0f, 5.0f);
+  glPopMatrix ();
+
+  if (mFbo)
+    mFbo->unbind ();
+
+  if (mFbo && mFbo->status ())
+  {
+    glClearColor (1, 1, 1, 1);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glPushMatrix ();
+    glLoadIdentity();
+    glTranslatef(-0.5f, 0.5f, -0.866025404f);
+    glScalef (1.0f / mWidth, -(1.0f / mHeight), 0.0f);
+    mFbo->paint (nux::Geometry (0, 0, mWidth, mHeight));
+    glPopMatrix ();
+
+    nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
+        nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID (mFbo->texture(),
+                                                                          mWidth, mHeight, 1, nux::BITFMT_R8G8B8A8);
+
+    nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
+
+    nux::Geometry geo = nux::Geometry (0, 0, mWidth, mHeight);
+    BackgroundEffectHelper::monitor_rect_ = geo;
+  }
+
+  glMatrixMode(GL_PROJECTION);
+  glPushMatrix();
+
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+  glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT |
+               GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT | GL_SCISSOR_BIT);
+  mRootView->ProcessDraw (mWindowThread->GetGraphicsEngine (), true);
+  glMatrixMode(GL_PROJECTION);
+  glPopMatrix();
+  glMatrixMode(GL_MODELVIEW);
+  glPopMatrix();
+
+  glDrawBuffer(GL_BACK);
+  glReadBuffer(GL_BACK);
+
+  glPopAttrib();
+
+  glXSwapBuffers (mDisplay, mGlxWindow);
+
+  switch (mRotating)
+  {
+    case ModifierApplication::Both:
+      mTriangle->rotate ();
+      mSquare->rotate ();
+      break;
+    case ModifierApplication::Triangle:
+      mTriangle->rotate ();
+      break;
+    case ModifierApplication::Square:
+      mSquare->rotate ();
+      break;
+  }
+
+  return true;
+}
+
+void
+BaseContext::onWindowThreadCreation (nux::NThread *thread, void *data)
+{
+  BaseContext *bc = static_cast <BaseContext *> (data);
+
+  bc->mRootView = new EffectView ();
+  bc->mRootView->SetGeometry (nux::Geometry (0, 0, 640, 480));
+  bc->mNuxReady = true;
+  BackgroundEffectHelper::blur_type = unity::BLUR_ACTIVE;
+}
+
+int main (int argc, char **argv)
+{
+  Display *display = XOpenDisplay (NULL);
+  nux::NuxInitialize (0);
+  GLFuncs::init ();
+	g_type_init ();
+  g_thread_init (NULL);
+  gtk_init(&argc, &argv);
+
+  BaseContext *bc = new BaseContext (display);
+
+  bc->run ();
+
+  delete bc;
+
+  XCloseDisplay (display);
+
+  return 0;
+}
+
+