Merge lp:~unity-team/unity/unity.linaro-desktop-safe-gles2 into lp:unity

[Jay Taoko]

Desktop safe OpenGL ES 2.0 branch from Linaro's Graphics WG
    - This branch protects OpenGL ES 2.0 specific code with a build time option (BUILD_GLES)
    - The branch does not affect the runtime execution of Unity on the desktop if BUILD_GLES is not activated

Authors:
    <email address hidden>
    <email address hidden>

[Jason Smith (jassmith)]

Testing on both of my systems reveals no differences. +1 for merge

review: Approve

[Jay Taoko (jaytaoko)]

Nothing to report after testing for a day. Works fine.
+1

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-12-19 22:18:53 +0000
+++ CMakeLists.txt	2012-01-26 00:46:25 +0000
@@ -17,6 +17,9 @@
 set (CMAKE_CXX_FLAGS_DEBUG "-g3")
 set (CMAKE_CXX_FLAGS_RELEASE "")
 
+if (BUILD_GLES)
+	SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNUX_OPENGLES_20 -DUSE_GLES")
+endif (BUILD_GLES)
 
 #
 # Niceties
@@ -136,6 +139,7 @@
 add_subdirectory(guides)
 add_subdirectory(standalone-clients EXCLUDE_FROM_ALL)
 
+
 #
 # GSettings Schema
 #

=== modified file 'plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.cpp'
--- plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.cpp	2011-12-23 07:19:07 +0000
+++ plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.cpp	2012-01-26 00:46:25 +0000
@@ -438,13 +438,21 @@
 
 bool
 UnityMTGrabHandlesWindow::glDraw(const GLMatrix&            transform,
+#ifdef USE_GLES
+                                 const GLWindowPaintAttrib& attrib,
+#else
                                  GLFragment::Attrib&      fragment,
+#endif
                                  const CompRegion&          region,
                                  unsigned int              mask)
 {
   /* Draw the window on the bottom, we will be drawing the
    * handles on top */
+#ifdef USE_GLES
+  bool status = gWindow->glDraw(transform, attrib, region, mask);
+#else
   bool status = gWindow->glDraw(transform, fragment, region, mask);
+#endif
 
   if (mHandles && mHandles->visible())
   {
@@ -464,10 +472,17 @@
         GLTexture::MatrixList matl;
         GLTexture::Matrix     mat = tex->matrix();
         CompRegion        paintRegion(region);
+#ifdef USE_GLES
+        GLWindowPaintAttrib   wAttrib(attrib);
+#endif
 
         /* We can reset the window geometry since it will be
          * re-added later */
+#ifdef USE_GLES
+        gWindow->vertexBuffer()->begin();
+#else
         gWindow->geometry().reset();
+#endif
 
         /* Not sure what this does, but it is necessary
          * (adjusts for scale?) */
@@ -483,23 +498,35 @@
          * dim (so we get a nice render for things like
          * wobbly etc etc */
         gWindow->glAddGeometry(matl, reg, paintRegion);
-
+#ifdef USE_GLES
+        gWindow->vertexBuffer()->end();
+        wAttrib.opacity = mHandles->opacity();
+#else
         /* Did it succeed? */
         if (gWindow->geometry().vertices)
         {
           fragment.setOpacity(mHandles->opacity());
           /* Texture rendering set-up */
           us->gScreen->setTexEnvMode(GL_MODULATE);
+#endif
           glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
           /* Draw the dim texture with all of it's modified
            * geometry glory */
-          gWindow->glDrawTexture(tex, fragment, mask | PAINT_WINDOW_BLEND_MASK
+          gWindow->glDrawTexture(tex,
+#ifdef USE_GLES
+                                 transform, wAttrib,
+#else
+                                 fragment,
+#endif
+                                 mask | PAINT_WINDOW_BLEND_MASK
                                  | PAINT_WINDOW_TRANSLUCENT_MASK |
                                  PAINT_WINDOW_TRANSFORMED_MASK);
           /* Texture rendering tear-down */
           glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+#ifndef USE_GLES
           us->gScreen->setTexEnvMode(GL_REPLACE);
         }
+#endif
       }
 
       handle++;

=== modified file 'plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.h'
--- plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.h	2011-12-22 12:55:41 +0000
+++ plugins/unity-mt-grab-handles/src/unity-mt-grab-handles.h	2012-01-26 00:46:25 +0000
@@ -229,7 +229,11 @@
   void moveNotify(int dx, int dy, bool immediate);
 
   bool glDraw(const GLMatrix&,
+#ifdef USE_GLES
+              const GLWindowPaintAttrib&,
+#else
               GLFragment::Attrib&,
+#endif
               const CompRegion&,
               unsigned int);
 

=== modified file 'plugins/unitydialog/src/unitydialog.cpp'
--- plugins/unitydialog/src/unitydialog.cpp	2012-01-18 18:47:55 +0000
+++ plugins/unitydialog/src/unitydialog.cpp	2012-01-26 00:46:25 +0000
@@ -420,7 +420,12 @@
 /* Collect textures */
 void
 UnityDialogWindow::glDrawTexture(GLTexture*          texture,
+#ifdef USE_GLES
+                                 const GLMatrix            &transform,
+                                 const GLWindowPaintAttrib &attrib,
+#else
                                  GLFragment::Attrib& fa,
+#endif
                                  unsigned int       mask)
 {
   unity::PaintInfoCollector::Active ()->processTexture (texture);
@@ -448,7 +453,11 @@
 {
   /* We can reset the window geometry since it will be
    * re-added later */
+#ifdef USE_GLES
+  GLWindow::get (w)->vertexBuffer()->begin();
+#else
   GLWindow::get (w)->geometry().reset();
+#endif
 
   for (unsigned int i = 0; i < collectedMatrixLists.size (); i++)
   {
@@ -462,6 +471,10 @@
      * wobbly etc etc */
     GLWindow::get (w)->glAddGeometry(matl, reg, paintRegion, min, max);
   }
+
+#ifdef USE_GLES
+  GLWindow::get (w)->vertexBuffer()->end();
+#endif
 }
 
 void
@@ -497,7 +510,11 @@
 }
 
 void
-unity::TexGeometryCollection::addGeometriesAndDrawTextureForWindow(CompWindow *w, unsigned int mask)
+unity::TexGeometryCollection::addGeometriesAndDrawTextureForWindow(CompWindow *w,
+#ifdef USE_GLES
+                                                                   const GLMatrix &transform,
+#endif
+                                                                   unsigned int mask)
 {
   if (mTexture && mGeometries.status ())
   {
@@ -509,6 +526,25 @@
 
     mGeometries.addGeometryForWindow (w, paintRegion);
 
+#ifdef USE_GLES
+    UnityDialogScreen *uds = UnityDialogScreen::get (screen);
+    GLWindowPaintAttrib attrib (gWindow->lastPaintAttrib());
+    unsigned int glDrawTextureIndex = gWindow->glDrawTextureGetCurrentIndex();
+    /* Texture rendering set-up */
+//    uds->gScreen->setTexEnvMode(GL_MODULATE);
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    /* Draw the dim texture with all of it's modified
+     * geometry glory */
+    gWindow->glDrawTextureSetCurrentIndex(MAXSHORT);
+    gWindow->glDrawTexture(mTexture, transform, attrib, mask
+					      | PAINT_WINDOW_BLEND_MASK
+					      | PAINT_WINDOW_TRANSLUCENT_MASK
+					      | PAINT_WINDOW_TRANSFORMED_MASK);
+    gWindow->glDrawTextureSetCurrentIndex(glDrawTextureIndex);
+    /* Texture rendering tear-down */
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    uds->gScreen->setTexEnvMode(GL_REPLACE);
+#else
     if (gWindow->geometry().vertices)
     {
 	UnityDialogScreen *uds = UnityDialogScreen::get (screen);
@@ -528,6 +564,7 @@
 	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 	uds->gScreen->setTexEnvMode(GL_REPLACE);
     }
+#endif
   }
 }
 
@@ -581,10 +618,18 @@
 }
 
 void
-unity::PaintInfoCollector::drawGeometriesForWindow(CompWindow *w, unsigned int pm)
+unity::PaintInfoCollector::drawGeometriesForWindow(CompWindow *w,
+#ifdef USE_GLES
+                                                   const GLMatrix &transform,
+#endif
+                                                   unsigned int pm)
 {
   for (unity::TexGeometryCollection &tcg : mCollection)
+#if USE_GLES
+    tcg.addGeometriesAndDrawTextureForWindow (w, transform, pm);
+#else
     tcg.addGeometriesAndDrawTextureForWindow (w, pm);
+#endif
 }
 
 unity::PaintInfoCollector * unity::PaintInfoCollector::active_collector = NULL;
@@ -599,7 +644,11 @@
 
 bool
 UnityDialogWindow::glDraw(const GLMatrix& transform,
+#ifdef USE_GLES
+                          const GLWindowPaintAttrib& attrib,
+#else
                           GLFragment::Attrib& fragment,
+#endif
                           const CompRegion& region,
                           unsigned int mask)
 {
@@ -610,7 +659,13 @@
 
   /* Draw the window on the bottom, we will be drawing the
    * dim render on top */
-  bool status = gWindow->glDraw(transform, fragment, region, mask);
+  bool status = gWindow->glDraw(transform,
+#ifdef USE_GLES
+                                attrib,
+#else
+                                fragment,
+#endif
+                                region, mask);
 
   UNITY_DIALOG_SCREEN(screen);
 
@@ -618,10 +673,17 @@
   {
     GLTexture::MatrixList matl;
     GLTexture::Matrix     mat = tex->matrix();
+#ifdef USE_GLES
+    GLWindowPaintAttrib   wAttrib(attrib);
+#endif
 
     /* We can reset the window geometry since it will be
      * re-added later */
+#ifdef USE_GLES
+    gWindow->vertexBuffer()->begin();
+#else
     gWindow->geometry().reset();
+#endif
 
     /* Scale the dim render by the ratio of dim size
      * to window size */
@@ -642,7 +704,28 @@
      * dim (so we get a nice render for things like
      * wobbly etc etc */
     gWindow->glAddGeometry(matl, reg, paintRegion);
+#ifdef USE_GLES
+    gWindow->vertexBuffer()->end();
+#endif
 
+#ifdef USE_GLES
+    unsigned int glDrawTextureIndex = gWindow->glDrawTextureGetCurrentIndex();
+    wAttrib.opacity = mShadeProgress;
+    /* Texture rendering set-up */
+//    uds->gScreen->setTexEnvMode(GL_MODULATE);
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    /* Draw the dim texture with all of it's modified
+     * geometry glory */
+    gWindow->glDrawTextureSetCurrentIndex(MAXSHORT);
+    gWindow->glDrawTexture(tex, transform, attrib, mask
+                                              | PAINT_WINDOW_BLEND_MASK
+                                              | PAINT_WINDOW_TRANSLUCENT_MASK
+                                              | PAINT_WINDOW_TRANSFORMED_MASK);
+    gWindow->glDrawTextureSetCurrentIndex(glDrawTextureIndex);
+    /* Texture rendering tear-down */
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    uds->gScreen->setTexEnvMode(GL_REPLACE);
+#else
     /* Did it succeed? */
     if (gWindow->geometry().vertices)
     {
@@ -662,6 +745,7 @@
       glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
       uds->gScreen->setTexEnvMode(GL_REPLACE);
     }
+#endif
   }
 
   for (CompWindow* w : mTransients)
@@ -674,7 +758,11 @@
       unity::PaintInfoCollector pc (w);
 
       pc.collect();
-      pc.drawGeometriesForWindow (window, mask);
+      pc.drawGeometriesForWindow (window,
+#ifdef USE_GLES
+                                  transform,
+#endif
+                                  mask);
     }
   }
 

=== modified file 'plugins/unitydialog/src/unitydialog.h'
--- plugins/unitydialog/src/unitydialog.h	2012-01-18 18:47:55 +0000
+++ plugins/unitydialog/src/unitydialog.h	2012-01-26 00:46:25 +0000
@@ -64,7 +64,13 @@
 			int                         max);
       void setTexture (GLTexture *);
 
+#ifdef USE_GLES
+      void addGeometriesAndDrawTextureForWindow (CompWindow     *w,
+						 const GLMatrix &transform,
+                                                 unsigned int    mask);
+#else
       void addGeometriesAndDrawTextureForWindow (CompWindow *, unsigned int pm);
+#endif
 
     private:
       GLTexture*         mTexture;
@@ -78,7 +84,13 @@
       PaintInfoCollector (CompWindow *w);
 
       void collect ();
+#ifdef USE_GLES
+      void drawGeometriesForWindow (CompWindow     *w,
+				    const GLMatrix &transform,
+				    unsigned int    pm);
+#else
       void drawGeometriesForWindow (CompWindow *w, unsigned int pm);
+#endif
 
       void processGeometry (const GLTexture::MatrixList &ml,
 			    const CompRegion            &r,
@@ -242,7 +254,12 @@
 public:
 
   bool
-  glDraw(const GLMatrix&, GLFragment::Attrib&,
+  glDraw(const GLMatrix&,
+#ifdef USE_GLES
+         const GLWindowPaintAttrib&,
+#else
+         GLFragment::Attrib&,
+#endif
          const CompRegion&, unsigned int);
 
   bool
@@ -258,7 +275,12 @@
 
   void
   glDrawTexture(GLTexture* texture,
+#ifdef USE_GLES
+                const GLMatrix& transform,
+                const GLWindowPaintAttrib& attrib,
+#else
                 GLFragment::Attrib& attrib,
+#endif
                 unsigned int mask);
 
 

=== modified file 'plugins/unityshell/src/IconRenderer.cpp'
--- plugins/unityshell/src/IconRenderer.cpp	2012-01-04 01:43:15 +0000
+++ plugins/unityshell/src/IconRenderer.cpp	2012-01-26 00:46:25 +0000
@@ -39,6 +39,14 @@
 namespace ui
 {
 
+#ifdef USE_GLES
+  #define VertexShaderHeader   "#version 100\n"
+  #define FragmentShaderHeader "#version 100\n precision mediump float;\n"
+#else
+  #define VertexShaderHeader   "#version 120\n"
+  #define FragmentShaderHeader "#version 110\n"
+#endif
+
 /*
   Use this shader to pass vertices in screen coordinates in the C++ code and compute use
   the fragment shader to perform the texture perspective correct division.
@@ -60,9 +68,9 @@
 #define LUMIN_BLUE "0.055"
 
 nux::NString gPerspectiveCorrectShader = TEXT(
-"[Vertex Shader]                                    \n\
-#version 120                                        \n\
-uniform mat4 ViewProjectionMatrix;                  \n\
+"[Vertex Shader]                                    \n"
+VertexShaderHeader
+"uniform mat4 ViewProjectionMatrix;                 \n\
                                                     \n\
 attribute vec4 iTexCoord0;                          \n\
 attribute vec4 iVertex;                             \n\
@@ -75,9 +83,9 @@
     gl_Position =  ViewProjectionMatrix * iVertex;  \n\
 }                                                   \n\
                                                     \n\
-[Fragment Shader]                                   \n\
-#version 110                                        \n\
-                                                    \n\
+[Fragment Shader]                                   \n"
+FragmentShaderHeader
+"                                                   \n\
 varying vec4 varyTexCoord0;                         \n\
                                                     \n\
 uniform sampler2D TextureObject0;                   \n\
@@ -649,8 +657,13 @@
     // Perspective correct
     v0.x, v0.y, 0.0f, 1.0f,     s0 / v0.w, t0 / v0.w, 0.0f, 1.0f / v0.w,
     v1.x, v1.y, 0.0f, 1.0f,     s1 / v1.w, t1 / v1.w, 0.0f, 1.0f / v1.w,
-    v2.x, v2.y, 0.0f, 1.0f,     s2 / v2.w, t2 / v2.w, 0.0f, 1.0f / v2.w,
-    v3.x, v3.y, 0.0f, 1.0f,     s3 / v3.w, t3 / v3.w, 0.0f, 1.0f / v3.w,
+#ifdef USE_GLES
+    v3.x, v3.y, 0.0f, 1.0f,     s3 / v3.w, t3 / v3.w, 0.0f, 1.0f / v3.w,
+    v2.x, v2.y, 0.0f, 1.0f,     s2 / v2.w, t2 / v2.w, 0.0f, 1.0f / v2.w,
+#else
+    v2.x, v2.y, 0.0f, 1.0f,     s2 / v2.w, t2 / v2.w, 0.0f, 1.0f / v2.w,
+    v3.x, v3.y, 0.0f, 1.0f,     s3 / v3.w, t3 / v3.w, 0.0f, 1.0f / v3.w,
+#endif
   };
 
   CHECKGL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0));
@@ -681,6 +694,7 @@
       local::shader_program_uv_persp_correction->SetUniformLocMatrix4fv((GLint)VPMatrixLocation, 1, false, (GLfloat*) & (_stored_projection_matrix.m));
     }
   }
+#ifndef USE_GLES
   else
   {
     local::asm_shader->Begin();
@@ -698,6 +712,7 @@
     CHECKGL(glMatrixMode(GL_PROJECTION));
     CHECKGL(glLoadMatrixf((float*) GfxContext.GetOpenGLProjectionMatrix().m));
   }
+#endif
 
   CHECKGL(glEnableVertexAttribArrayARB(VertexLocation));
   CHECKGL(glVertexAttribPointerARB((GLuint)VertexLocation, 4, GL_FLOAT, GL_FALSE, 32, VtxBuffer));
@@ -716,8 +731,13 @@
     CHECKGL(glUniform4fARB(DesatFactor, arg.saturation, arg.saturation, arg.saturation, arg.saturation));
 
     nux::GetWindowThread()->GetGraphicsEngine().SetTexture(GL_TEXTURE0, icon);
+#ifdef USE_GLES
+    CHECKGL(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
+#else
     CHECKGL(glDrawArrays(GL_QUADS, 0, 4));
+#endif
   }
+#ifndef USE_GLES
   else
   {
     CHECKGL(glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, bg_color.red, bg_color.green, bg_color.blue, bg_color.alpha));
@@ -726,6 +746,7 @@
     nux::GetWindowThread()->GetGraphicsEngine().SetTexture(GL_TEXTURE0, icon);
     CHECKGL(glDrawArrays(GL_QUADS, 0, 4));
   }
+#endif
 
   if (VertexLocation != -1)
     CHECKGL(glDisableVertexAttribArrayARB(VertexLocation));

=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.cpp'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-01-05 02:47:09 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.cpp	2012-01-26 00:46:25 +0000
@@ -17,6 +17,7 @@
  * Authored By: Sam Spilsbury <[e-mail]>
  */
 
+#ifndef USE_GLES
 #include "ScreenEffectFramebufferObject.h"
 #include "BackgroundEffectHelper.h"
 #include <NuxCore/Logger.h>
@@ -232,3 +233,6 @@
   if (mFBTexture)
     glDeleteTextures (1, &mFBTexture);
 }
+
+#endif // USE_GLES
+

=== modified file 'plugins/unityshell/src/ScreenEffectFramebufferObject.h'
--- plugins/unityshell/src/ScreenEffectFramebufferObject.h	2011-12-16 09:46:35 +0000
+++ plugins/unityshell/src/ScreenEffectFramebufferObject.h	2012-01-26 00:46:25 +0000
@@ -20,6 +20,7 @@
 #ifndef UNITY_SCREENEFFECT_FRAMEBUFFER_H
 #define UNITY_SCREENEFFECT_FRAMEBUFFER_H
 
+#ifndef USE_GLES
 #include <Nux/Nux.h>
 
 namespace unity
@@ -84,4 +85,5 @@
 };
 } // namespace unity
 
+#endif // USE_GLES
 #endif

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-01-25 15:59:42 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-01-26 00:46:25 +0000
@@ -114,7 +114,9 @@
   , damaged(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
+#ifndef USE_GLES
   , _active_fbo (0)
+#endif
   , dash_is_open_ (false)
   , grab_index_ (0)
   , painting_tray_ (false)
@@ -128,6 +130,7 @@
   int (*old_handler)(Display*, XErrorEvent*);
   old_handler = XSetErrorHandler(NULL);
 
+#ifndef USE_GLES
   /* Ensure OpenGL version is 1.4+. */
   version = get_opengl_version_f32((const gchar*) glGetString(GL_VERSION));
   if (version < 1.4f)
@@ -183,6 +186,7 @@
       failed = true;
     }
   }
+#endif
 
   if (!failed)
   {
@@ -199,16 +203,27 @@
      CompositeScreenInterface::setHandler(cScreen);
      GLScreenInterface::setHandler(gScreen);
 
+#ifdef USE_GLES
+     gScreen->glPaintCompositedOutputSetEnabled (this, true);
+#endif
+
      PluginAdapter::Initialize(screen);
      WindowManager::SetDefault(PluginAdapter::Default());
 
      StartupNotifyService::Default()->SetSnDisplay(screen->snDisplay(), screen->screenNum());
 
      nux::NuxInitialize(0);
+#ifndef USE_GLES
      wt = nux::CreateFromForeignWindow(cScreen->output(),
 				       glXGetCurrentContext(),
 				       &UnityScreen::initUnity,
 				       this);
+#else
+     wt = nux::CreateFromForeignWindow(cScreen->output(),
+				       eglGetCurrentContext(),
+				       &UnityScreen::initUnity,
+				       this);
+#endif
 
      wt->RedrawRequested.connect(sigc::mem_fun(this, &UnityScreen::onRedrawRequested));
 
@@ -226,6 +241,7 @@
      _edge_timeout = optionGetLauncherRevealEdgeTimeout ();
      _in_paint = false;
 
+#ifndef USE_GLES
     void *dlhand = dlopen ("libunityshell.so", RTLD_LAZY);
 
     if (dlhand)
@@ -242,6 +258,7 @@
        uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
        uScreen->_fbo->onScreenSizeChanged (geometry);
      }
+#endif
 
      optionSetBackgroundColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetLauncherHideModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -443,6 +460,7 @@
 
 void UnityScreen::nuxPrologue()
 {
+#ifndef USE_GLES
   /* Vertex lighting isn't used in Unity, we disable that state as it could have
    * been leaked by another plugin. That should theoretically be switched off
    * right after PushAttrib since ENABLE_BIT is meant to restore the LIGHTING
@@ -459,12 +477,14 @@
 
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
+#endif
 
   glGetError();
 }
 
 void UnityScreen::nuxEpilogue()
 {
+#ifndef USE_GLES
   (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, _active_fbo);
 
   glMatrixMode(GL_PROJECTION);
@@ -486,6 +506,11 @@
   glReadBuffer(GL_BACK);
 
   glPopAttrib();
+#else
+  glDepthRangef(0, 1);
+  //glViewport(-1, -1, 2, 2);
+  gScreen->resetRasterPos();
+#endif
 
   glDisable(GL_SCISSOR_TEST);
 }
@@ -500,6 +525,7 @@
 
 void UnityScreen::paintPanelShadow(const GLMatrix& matrix)
 {
+#ifndef USE_GLES
   if (relayoutSourceId > 0)
     return;
 
@@ -559,6 +585,86 @@
       glDisable(GL_BLEND);
     }
   }
+#else
+#warning Panel shadow not properly implemented for GLES2
+  return;
+
+  if (relayoutSourceId > 0)
+    return;
+
+  if (PluginAdapter::Default()->IsExpoActive())
+    return;
+
+  nuxPrologue();
+
+  CompOutput* output = _last_output;
+  float vc[4];
+  float h = 20.0f;
+  float w = 1.0f;
+  float panel_h = 24.0f;
+
+  float x1 = output->x();
+  float y1 = output->y() + panel_h;
+  float x2 = x1 + output->width();
+  float y2 = y1 + h;
+
+  vc[0] = x1;
+  vc[1] = x2;
+  vc[2] = y1;
+  vc[3] = y2;
+
+  if (!dash_is_open_ && panel_controller_->opacity() > 0.0f)
+  {
+    foreach(GLTexture * tex, _shadow_texture)
+    {
+      std::vector<GLfloat>  vertexData;
+      std::vector<GLfloat>  textureData;
+      std::vector<GLushort> colorData;
+      GLVertexBuffer       *streamingBuffer = GLVertexBuffer::streamingBuffer();
+      bool                  wasBlend = glIsEnabled(GL_BLEND);
+
+      if (!wasBlend)
+        glEnable(GL_BLEND);
+
+      GL::activeTexture(GL_TEXTURE0);
+      tex->enable(GLTexture::Fast);
+
+      glTexParameteri(tex->target(), GL_TEXTURE_WRAP_S, GL_REPEAT);
+
+      colorData = { 0xFFFF, 0xFFFF, 0xFFFF,
+                    (GLushort)(panel_controller_->opacity() * 0xFFFF)
+                  };
+
+      vertexData = {
+        vc[0], vc[2], 0,
+        vc[0], vc[3], 0,
+        vc[1], vc[2], 0,
+        vc[1], vc[3], 0,
+      };
+
+      textureData = {
+        COMP_TEX_COORD_X(tex->matrix(), 0), COMP_TEX_COORD_Y(tex->matrix(), 0),
+        COMP_TEX_COORD_X(tex->matrix(), 0), COMP_TEX_COORD_Y(tex->matrix(), h),
+        COMP_TEX_COORD_X(tex->matrix(), w), COMP_TEX_COORD_Y(tex->matrix(), 0),
+        COMP_TEX_COORD_X(tex->matrix(), w), COMP_TEX_COORD_Y(tex->matrix(), h),
+      };
+
+      streamingBuffer->begin(GL_TRIANGLE_STRIP);
+
+      streamingBuffer->addColors(1, &colorData[0]);
+      streamingBuffer->addVertices(4, &vertexData[0]);
+      streamingBuffer->addTexCoords(0, 4, &textureData[0]);
+
+      streamingBuffer->end();
+      streamingBuffer->render(matrix);
+
+      tex->disable();
+      if (!wasBlend)
+        glDisable(GL_BLEND);
+    }
+  }
+  nuxEpilogue();
+#endif
 }
 
 void
@@ -573,11 +679,16 @@
   wy = y + (last_bound.height - height) / 2;
 }
 
+#ifdef USE_GLES
+void UnityScreen::paintDisplay()
+#else
 void UnityScreen::paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask)
+#endif
 {
   CompOutput *output = _last_output;
   Window     tray_xid = panel_controller_->GetTrayXid ();
 
+#ifndef USE_GLES
   bool was_bound = _fbo->bound ();
   _fbo->unbind ();
 
@@ -596,6 +707,11 @@
   nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture =
       nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(_fbo->texture(),
                                                                        screen->width (), screen->height(), 1, nux::BITFMT_R8G8B8A8);
+#else
+  nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture = 
+    nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(gScreen->fbo ()->tex ()->name (),
+      output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
+#endif
 
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
 
@@ -603,6 +719,13 @@
   nux::Geometry oGeo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
   BackgroundEffectHelper::monitor_rect_ = geo;
 
+#ifdef USE_GLES
+  GLint fboID;
+  // Nux renders to the referenceFramebuffer when it's embedded.
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fboID);
+  wt->GetWindowCompositor().SetReferenceFramebuffer(fboID, geo);
+#endif
+
   nuxPrologue();
   _in_paint = true;
   wt->RenderInterfaceFromForeignCmd (&oGeo);
@@ -617,36 +740,56 @@
     {
       GLMatrix oTransform;
       UnityWindow  *uTrayWindow = UnityWindow::get (tray);
+#ifndef USE_GLES
       GLFragment::Attrib attrib (uTrayWindow->gWindow->lastPaintAttrib());
+#else
+      GLWindowPaintAttrib attrib (uTrayWindow->gWindow->lastPaintAttrib());
+#endif
       unsigned int oldGlAddGeometryIndex = uTrayWindow->gWindow->glAddGeometryGetCurrentIndex ();
       unsigned int oldGlDrawIndex = uTrayWindow->gWindow->glDrawGetCurrentIndex ();
+#ifndef USE_GLES
       unsigned int oldGlDrawGeometryIndex = uTrayWindow->gWindow->glDrawGeometryGetCurrentIndex ();
+#endif
 
+#ifndef USE_GLES
       attrib.setOpacity (OPAQUE);
       attrib.setBrightness (BRIGHT);
       attrib.setSaturation (COLOR);
+#else
+      attrib.opacity = OPAQUE;
+      attrib.brightness = BRIGHT;
+      attrib.saturation = COLOR;
+#endif
 
       oTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
+#ifndef USE_GLES
       glPushMatrix ();
       glLoadMatrixf (oTransform.getMatrix ());
+#endif
 
       painting_tray_ = true;
 
       /* force the use of the core functions */
       uTrayWindow->gWindow->glDrawSetCurrentIndex (MAXSHORT);
       uTrayWindow->gWindow->glAddGeometrySetCurrentIndex ( MAXSHORT);
+#ifndef USE_GLES
       uTrayWindow->gWindow->glDrawGeometrySetCurrentIndex (MAXSHORT);
+#endif
       uTrayWindow->gWindow->glDraw (oTransform, attrib, infiniteRegion,
 				     PAINT_WINDOW_TRANSFORMED_MASK |
 				     PAINT_WINDOW_BLEND_MASK |
 				     PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK);
+#ifndef USE_GLES
       uTrayWindow->gWindow->glDrawGeometrySetCurrentIndex (oldGlDrawGeometryIndex);
+#endif
       uTrayWindow->gWindow->glAddGeometrySetCurrentIndex (oldGlAddGeometryIndex);
       uTrayWindow->gWindow->glDrawSetCurrentIndex (oldGlDrawIndex);
       painting_tray_ = false;
 
+#ifndef USE_GLES
       glPopMatrix ();
+#endif
     }
   }
 
@@ -1009,6 +1152,7 @@
   allowWindowPaint = true;
   _last_output = output;
 
+#ifndef USE_GLES
   /* bind the framebuffer here
    * - it will be unbound and flushed
    *   to the backbuffer when some
@@ -1020,16 +1164,43 @@
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
   _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+#endif
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
   ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
 
+#ifndef USE_GLES
   if (doShellRepaint)
     paintDisplay(region, transform, mask);
+#endif
 
   return ret;
 }
 
+#ifdef USE_GLES
+void UnityScreen::glPaintCompositedOutput (const CompRegion &region,
+                                           GLFramebufferObject *fbo,
+                                           unsigned int        mask)
+{
+  bool useFbo = false;
+
+  if (doShellRepaint)
+  {
+    oldFbo = fbo->bind ();
+    useFbo = fbo->checkStatus () && fbo->tex ();
+    if (!useFbo) {
+	printf ("bailing from UnityScreen::glPaintCompositedOutput");
+	GLFramebufferObject::rebind (oldFbo);
+	return;
+    }
+    paintDisplay();
+    GLFramebufferObject::rebind (oldFbo);
+  }
+
+  gScreen->glPaintCompositedOutput(region, fbo, mask);
+}
+#endif
+
 /* called whenever a plugin needs to paint the entire scene
  * transformed */
 
@@ -1111,7 +1282,9 @@
         PluginAdapter::Default()->OnScreenGrabbed();
       else if (event->xfocus.mode == NotifyUngrab)
         PluginAdapter::Default()->OnScreenUngrabbed();
+#ifndef USE_GLES
       cScreen->damageScreen();  // evil hack
+#endif
       if (_key_nav_mode_requested)
         launcher.startKeyNavMode();
       _key_nav_mode_requested = false;
@@ -1770,7 +1943,11 @@
  * and if so paint nux and stop us from painting
  * other windows or on top of the whole screen */
 bool UnityWindow::glDraw(const GLMatrix& matrix,
+#ifndef USE_GLES
                          GLFragment::Attrib& attrib,
+#else
+                         const GLWindowPaintAttrib& attrib,
+#endif
                          const CompRegion& region,
                          unsigned int mask)
 {
@@ -1786,7 +1963,11 @@
       {
         if (xwns[i] == id)
         {
+#ifdef USE_GLES
+          uScreen->paintDisplay();
+#else
           uScreen->paintDisplay(region, matrix, mask);
+#endif          
           break;
         }
       }
@@ -2258,11 +2439,13 @@
   if (!needsRelayout)
     return;
 
+#ifndef USE_GLES
   if (GL::fbo)
   {
     uScreen->_fbo = ScreenEffectFramebufferObject::Ptr (new ScreenEffectFramebufferObject (glXGetProcAddressP, geometry));
     uScreen->_fbo->onScreenSizeChanged (geometry);
   }
+#endif
 
   UScreen *uscreen = UScreen::GetDefault();
   int primary_monitor = uscreen->GetPrimaryMonitor();

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-01-20 06:47:42 +0000
+++ plugins/unityshell/src/unityshell.h	2012-01-26 00:46:25 +0000
@@ -49,7 +49,9 @@
 #include "DebugDBusInterface.h"
 #include "SwitcherController.h"
 #include "UBusWrapper.h"
+#ifndef USE_GLES
 #include "ScreenEffectFramebufferObject.h"
+#endif
 
 #include "compizminimizedwindowhandler.h"
 #include "BGHash.h"
@@ -130,7 +132,11 @@
   void nuxEpilogue();
 
   /* nux draw wrapper */
+#ifdef USE_GLES
+  void paintDisplay();
+#else
   void paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask);
+#endif
   void paintPanelShadow(const GLMatrix& matrix);
 
   void preparePaint (int ms);
@@ -151,6 +157,11 @@
                      const CompRegion&,
                      CompOutput*,
                      unsigned int);
+#ifdef USE_GLES
+  void glPaintCompositedOutput (const CompRegion    &region,
+                                GLFramebufferObject *fbo,
+                                unsigned int         mask);
+#endif
 
   /* paint in the special case that the output is transformed */
   void glPaintTransformedOutput(const GLScreenPaintAttrib&,
@@ -302,8 +313,12 @@
 
   unity::BGHash _bghash;
 
+#ifdef USE_GLES
+  GLFramebufferObject *oldFbo;
+#else
   ScreenEffectFramebufferObject::Ptr _fbo;
   GLuint                             _active_fbo;
+#endif
 
   bool   queryForShader ();
 
@@ -314,7 +329,9 @@
   bool                   painting_tray_;
   unsigned int           tray_paint_mask_;
 
+#ifndef USE_GLES
   ScreenEffectFramebufferObject::GLXGetProcAddressProc glXGetProcAddressP;
+#endif
 
   friend class UnityWindow;
 };
@@ -351,7 +368,11 @@
 
   /* basic window draw function */
   bool glDraw(const GLMatrix& matrix,
+#ifndef USE_GLES
               GLFragment::Attrib& attrib,
+#else
+              const GLWindowPaintAttrib& attrib,
+#endif
               const CompRegion& region,
               unsigned intmask);