Merge lp:~sil2100/compiz/missing_versions into lp:~compiz/compiz/ubuntu

[Łukasz Zemczak]

Added the missing 1:0.9.7.4-0ubuntu2 and 1:0.9.7.4-0ubuntu3 from the precise PPA.

Added the missing 1:0.9.7.4-0ubuntu2 and 1:0.9.7.4-0ubuntu3 from the precise PPA, introducing the armel/armhf linaro fixes. Sadly, the introduced patch doesn't seem to build properly for arm - but non-arm builds succeed normally, so everything should be fine.

=== modified file 'debian/changelog'
--- debian/changelog	2012-04-10 09:02:47 +0000
+++ debian/changelog	2012-04-10 14:55:03 +0000
@@ -20,6 +20,29 @@
 
  -- Didier Roche <[e-mail]>  Thu, 05 Apr 2012 12:14:23 +0200
 
+compiz (1:0.9.7.4-0ubuntu3) precise; urgency=low
+
+  * fix typo in copying of the cmake files, so FindOpenGLES2.cmake ends up in
+    the right place for other packages (i.e. compiz-plugins-main on GLES2
+    capable arches)
+  * make copying the GLES2 cmake file architecture specifc instead of ignoring
+    if it is not found on arches that do not have it.
+
+ -- Oliver Grawert <[e-mail]>  Fri, 06 Apr 2012 13:55:13 +0200
+
+compiz (1:0.9.7.4-0ubuntu2) precise; urgency=low
+
+  * enable Linaros compiz-package-gles2.patch for armhf(/el) builds, thanks
+    to Alexandros Frantzis <[e-mail]> for creating it.
+  * enable quilt in debian/rules
+  * apply patches based on debian architecture via series.<arch> file
+    (stolen from eglibc)
+  * add build deps to libgl1-mesa-dev and libgl-dev for armhf builds
+  * add armel/armhf specific .install files since only a subset of modules can
+    be built yet.
+
+ -- Oliver Grawert <[e-mail]>  Thu, 05 Apr 2012 19:09:27 +0200
+
 compiz (1:0.9.7.4-0ubuntu1) precise; urgency=low
 
   * New upstream release

=== added file 'debian/compiz-core.install.armel'
--- debian/compiz-core.install.armel	1970-01-01 00:00:00 +0000
+++ debian/compiz-core.install.armel	2012-04-10 14:55:03 +0000
@@ -0,0 +1,8 @@
+debian/tmp/usr/bin/compiz*
+debian/tmp/usr/lib/libcompiz_core.so*
+debian/compiz-decorator usr/bin/
+debian/tmp/usr/share/compiz/*.png
+debian/tmp/usr/share/compiz/core.xml
+debian/source_compiz.py usr/share/apport/package-hooks
+debian/tmp/usr/share/locale
+debian/tmp/usr/share/applications/compiz.desktop

=== added file 'debian/compiz-core.install.armhf'
--- debian/compiz-core.install.armhf	1970-01-01 00:00:00 +0000
+++ debian/compiz-core.install.armhf	2012-04-10 14:55:03 +0000
@@ -0,0 +1,8 @@
+debian/tmp/usr/bin/compiz*
+debian/tmp/usr/lib/libcompiz_core.so*
+debian/compiz-decorator usr/bin/
+debian/tmp/usr/share/compiz/*.png
+debian/tmp/usr/share/compiz/core.xml
+debian/source_compiz.py usr/share/apport/package-hooks
+debian/tmp/usr/share/locale
+debian/tmp/usr/share/applications/compiz.desktop

=== added symlink 'debian/compiz-plugins.install.armel'
=== target is u'compiz-plugins.install.armhf'
=== added file 'debian/compiz-plugins.install.armhf'
--- debian/compiz-plugins.install.armhf	1970-01-01 00:00:00 +0000
+++ debian/compiz-plugins.install.armhf	2012-04-10 14:55:03 +0000
@@ -0,0 +1,11 @@
+debian/tmp/usr/*/compiz/*annotate.*
+debian/tmp/usr/*/compiz/*clone.*
+debian/tmp/usr/*/compiz/*commands.*
+debian/tmp/usr/*/compiz/*copytex.*
+debian/tmp/usr/*/compiz/*dbus.*
+debian/tmp/usr/*/compiz/*imgsvg.*
+debian/tmp/usr/*/compiz/*inotify.*
+debian/tmp/usr/*/compiz/*obs.*
+debian/tmp/usr/*/compiz/*screenshot.*
+debian/tmp/usr/*/compiz/*switcher.*
+debian/tmp/usr/*/compiz/*water.*

=== modified file 'debian/control'
--- debian/control	2012-03-30 11:26:17 +0000
+++ debian/control	2012-04-10 14:55:03 +0000
@@ -8,7 +8,9 @@
  debhelper (>= 7.0.50~), intltool, 
  libcairo2-dev,
  libdbus-glib-1-dev, libgconf2-dev, 
- libgl1-mesa-dev (>= 6.5.1) | libgl-dev, libglib2.0-dev, libboost-serialization1.46-dev,
+ libgl1-mesa-dev (>= 6.5.1) [!armhf !armel]| libgl-dev [!armhf !armel],
+ libegl1-mesa-dev [armhf armel], libgles2-mesa-dev [armhf armel],
+ libglib2.0-dev, libboost-serialization1.46-dev,
  libgtk2.0-dev, libgtk-3-dev, libice-dev (>= 1:1.0.1), 
  libmetacity-dev (>= 1:2.30.3-0ubuntu3), libpango1.0-dev, libpng12-dev | libpng-dev, librsvg2-dev, 
  libsm-dev (>= 1:1.0.1), libtool, libwnck-dev, libx11-dev, libxcomposite-dev (>= 1:0.3-2), libxext-dev,
@@ -18,7 +20,7 @@
  libxml2-dev, libxslt1-dev,
  libstartup-notification0-dev (>= 0.7),
  quilt (>= 0.40), x11proto-gl-dev (>= 1.4.8), xsltproc,
- libglu1-mesa-dev,
+ libglu1-mesa-dev [!armhf !armel],
  libglib2.0-dev,
  libglibmm-2.4-dev,
  kde-workspace-dev, kdelibs5-dev (>= 4:4.2.2),
@@ -73,7 +75,7 @@
 
 Package: compiz-dev
 Architecture: any
-Depends: compiz-core (= ${binary:Version}), ${misc:Depends}, libgl1-mesa-dev | libgl-dev, libpng-dev, libgtk-3-dev, libxcomposite-dev (>= 1:0.3-2), libxfixes-dev (>=1:4.0.1), libxdamage-dev (>= 1:1.0.3), libxinerama-dev, libxrandr-dev (>=2:1.1.0.2), libxcursor-dev, libice-dev (>= 1:1.0.1), libsm-dev (>= 1:1.0.1), libstartup-notification0-dev (>= 0.7), libxslt1-dev, libxml2-dev, libx11-xcb-dev, libglib2.0-dev, libglibmm-2.4-dev, compiz-plugins (= ${binary:Version}), libdecoration0-dev
+Depends: compiz-core (= ${binary:Version}), ${misc:Depends}, libgl1-mesa-dev [!armhf !armel]| libgl-dev [!armhf !armel], libegl1-mesa-dev [armhf armel], libgles2-mesa-dev [armhf armel], libpng-dev, libgtk-3-dev, libxcomposite-dev (>= 1:0.3-2), libxfixes-dev (>=1:4.0.1), libxdamage-dev (>= 1:1.0.3), libxinerama-dev, libxrandr-dev (>=2:1.1.0.2), libxcursor-dev, libice-dev (>= 1:1.0.1), libsm-dev (>= 1:1.0.1), libstartup-notification0-dev (>= 0.7), libxslt1-dev, libxml2-dev, libx11-xcb-dev, libglib2.0-dev, libglibmm-2.4-dev, compiz-plugins (= ${binary:Version}), libdecoration0-dev
 Description: OpenGL window and compositing manager - development files
  Compiz brings to life a variety of visual effects that make the Linux desktop
  easier to use, more powerful and intuitive, and more accessible for users

=== added file 'debian/patches/compiz-package-gles2.patch'
--- debian/patches/compiz-package-gles2.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/compiz-package-gles2.patch	2012-04-10 14:55:03 +0000
@@ -0,0 +1,8943 @@
+--- compiz-0.9.7.6.orig/CMakeLists.txt
++++ compiz-0.9.7.6/CMakeLists.txt
+@@ -119,6 +119,12 @@ install (
+     DESTINATION ${COMPIZ_DESTDIR}${libdir}/pkgconfig
+ )
+ 
++# temporarily disable plugins that aren't ported yed
++set (COMPIZ_DISABLE_PLUGIN_BLUR ON)
++set (COMPIZ_DISABLE_PLUGIN_CUBE ON)
++set (COMPIZ_DISABLE_PLUGIN_ROTATE ON)
++set (COMPIZ_DISABLE_PLUGIN_WOBBLY ON)
++
+ # Build Google Test and make its headers known
+ find_package (GTest)
+ 
+@@ -183,6 +189,12 @@ _print_configure_results ()
+ 
+ _check_compiz_cmake_macro (${CMAKE_MODULE_PATH_ORIG})
+ 
++# temporarily disable plugins that aren't ported yed
++SET(COMPIZ_DISABLE_PLUGIN_BLUR "ON")
++SET(COMPIZ_DISABLE_PLUGIN_CUBE "ON")
++SET(COMPIZ_DISABLE_PLUGIN_ROTATE "ON")
++SET(COMPIZ_DISABLE_PLUGIN_WATER "ON")
++SET(COMPIZ_DISABLE_PLUGIN_WOBBLY "ON")
+ # Enable coverage reporting for compiz
+ enable_coverage_report()
+ 
+--- compiz-0.9.7.6.orig/plugins/wobbly/CMakeLists.txt
++++ compiz-0.9.7.6/plugins/wobbly/CMakeLists.txt
+@@ -2,4 +2,4 @@ find_package (Compiz REQUIRED)
+ 
+ include (CompizPlugin)
+ 
+-compiz_plugin(wobbly PLUGINDEPS composite opengl)
++#compiz_plugin(wobbly PLUGINDEPS composite opengl)
+--- compiz-0.9.7.6.orig/plugins/rotate/CMakeLists.txt
++++ compiz-0.9.7.6/plugins/rotate/CMakeLists.txt
+@@ -2,4 +2,4 @@ find_package (Compiz REQUIRED)
+ 
+ include (CompizPlugin)
+ 
+-compiz_plugin(rotate PLUGINDEPS composite opengl cube)
+\ No newline at end of file
++#compiz_plugin(rotate PLUGINDEPS composite opengl cube)
+--- compiz-0.9.7.6.orig/plugins/decor/decor.xml.in
++++ compiz-0.9.7.6/plugins/decor/decor.xml.in
+@@ -30,7 +30,7 @@
+ 		<option name="active_shadow_opacity" type="float">
+ 		    <_short>Shadow Opacity</_short>
+ 		    <_long>Drop shadow opacity</_long>
+-		    <default>0.8</default>
++		    <default>0.5</default>
+ 		    <min>0.01</min>
+ 		    <max>6.0</max>
+ 		    <precision>0.01</precision>
+@@ -65,7 +65,7 @@
+ 		<option name="inactive_shadow_radius" type="float">
+ 		    <_short>Shadow Radius</_short>
+ 		    <_long>Drop shadow radius</_long>
+-		    <default>5.0</default>
++		    <default>8.0</default>
+ 		    <min>0.1</min>
+ 		    <max>13.0</max>
+ 		    <precision>0.1</precision>
+@@ -73,7 +73,7 @@
+ 		<option name="inactive_shadow_opacity" type="float">
+ 		    <_short>Shadow Opacity</_short>
+ 		    <_long>Drop shadow opacity</_long>
+-		    <default>0.4</default>
++		    <default>0.5</default>
+ 		    <min>0.01</min>
+ 		    <max>6.0</max>
+ 		    <precision>0.01</precision>
+@@ -100,7 +100,6 @@
+ 	    <option name="command" type="string">
+ 		<_short>Command</_short>
+ 		<_long>Decorator command line that is executed if no decorator is already running</_long>
+-		<default>/usr/bin/compiz-decorator</default>
+ 	    </option>
+ 	    <option name="mipmap" type="bool">
+ 		<_short>Mipmap</_short>
+--- compiz-0.9.7.6.orig/plugins/decor/src/decor.cpp
++++ compiz-0.9.7.6/plugins/decor/src/decor.cpp
+@@ -177,15 +177,13 @@ isAncestorTo (CompWindow *window,
+  */
+ 
+ bool
+-DecorWindow::glDraw (const GLMatrix     &transform,
+-		     GLFragment::Attrib &attrib,
+-		     const CompRegion   &region,
+-		     unsigned int       mask)
++DecorWindow::glDraw (const GLMatrix            &transform,
++		     const GLWindowPaintAttrib &attrib,
++		     const CompRegion          &region,
++		     unsigned int              mask)
+ {
+     bool status;
+ 
+-    status = gWindow->glDraw (transform, attrib, region, mask);
+-
+     /* Don't render dock decorations (shadows) on just any old window */
+     if (!(window->type () & CompWindowTypeDockMask))
+     {
+@@ -205,16 +203,19 @@ DecorWindow::glDraw (const GLMatrix
+ 	}
+     }
+ 
++    status = gWindow->glDraw (transform, attrib, region, mask);
++
+     return status;
+ }
+ 
+ void
+-DecorWindow::glDecorate (const GLMatrix     &transform,
+-		         GLFragment::Attrib &attrib,
+-		         const CompRegion   &region,
+-		         unsigned int       mask)
++DecorWindow::glDecorate (const GLMatrix            &transform,
++			 const GLWindowPaintAttrib &attrib,
++			 const CompRegion          &region,
++			 unsigned int              mask)
+ {
+     const CompRegion *preg = NULL;
++    GLboolean isBlendingEnabled;
+ 
+     if ((mask & (PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK |
+ 		 PAINT_WINDOW_WITH_OFFSET_MASK)))
+@@ -241,7 +242,7 @@ DecorWindow::glDecorate (const GLMatrix
+ 	GLTexture::MatrixList ml (1);
+ 	mask |= PAINT_WINDOW_BLEND_MASK;
+ 
+-	gWindow->geometry ().reset ();
++	gWindow->vertexBuffer ()->begin ();
+ 
+ 	for (int i = 0; i < wd->nQuad; i++)
+ 	{
+@@ -258,9 +259,14 @@ DecorWindow::glDecorate (const GLMatrix
+ 	    }
+ 	}
+ 
+-	if (gWindow->geometry ().vCount)
+-	    gWindow->glDrawTexture (wd->decor->texture->textures[0],
+-				    attrib, mask);
++	gWindow->vertexBuffer ()->end ();
++
++	glGetBooleanv (GL_BLEND, &isBlendingEnabled);
++	glEnable (GL_BLEND);
++	gWindow->glDrawTexture (wd->decor->texture->textures[0], transform,
++	                        attrib, mask);
++	if (!isBlendingEnabled)
++	    glDisable (GL_BLEND);
+     }
+     else if (wd && !reg.isEmpty () &&
+ 	     wd->decor->type == WINDOW_DECORATION_TYPE_WINDOW)
+@@ -272,14 +278,18 @@ DecorWindow::glDecorate (const GLMatrix
+ 	if (gWindow->textures ().empty ())
+ 	    return;
+ 
++	glGetBooleanv (GL_BLEND, &isBlendingEnabled);
++	glEnable (GL_BLEND);
++
+ 	if (gWindow->textures ().size () == 1)
+ 	{
+ 	    ml[0] = gWindow->matrices ()[0];
+-	    gWindow->geometry ().reset ();
++	    gWindow->vertexBuffer ()->begin ();
+ 	    gWindow->glAddGeometry (ml, window->frameRegion (), reg);
++	    gWindow->vertexBuffer ()->end ();
+ 
+-	    if (gWindow->geometry ().vCount)
+-		gWindow->glDrawTexture (gWindow->textures ()[0], attrib, mask);
++	    gWindow->glDrawTexture (gWindow->textures ()[0], transform,
++	                            attrib, mask);
+ 	}
+ 	else
+ 	{
+@@ -288,14 +298,17 @@ DecorWindow::glDecorate (const GLMatrix
+ 	    for (unsigned int i = 0; i < gWindow->textures ().size (); i++)
+ 	    {
+ 		ml[0] = gWindow->matrices ()[i];
+-		gWindow->geometry ().reset ();
++		gWindow->vertexBuffer ()->begin ();
+ 		gWindow->glAddGeometry (ml, regions[i], reg);
++		gWindow->vertexBuffer ()->end ();
+ 
+-		if (gWindow->geometry ().vCount)
+-		    gWindow->glDrawTexture (gWindow->textures ()[i], attrib,
+-					    mask);
++		gWindow->glDrawTexture (gWindow->textures ()[i], transform,
++		                        attrib, mask);
+ 	    }
+ 	}
++
++	if (!isBlendingEnabled)
++	    glDisable (GL_BLEND);
+     }
+ }
+ 
+--- compiz-0.9.7.6.orig/plugins/decor/src/decor.h
++++ compiz-0.9.7.6/plugins/decor/src/decor.h
+@@ -252,10 +252,10 @@ class DecorWindow :
+ 
+ 	void computeShadowRegion ();
+ 
+-	bool glDraw (const GLMatrix &, GLFragment::Attrib &,
++	bool glDraw (const GLMatrix &, const GLWindowPaintAttrib &,
+ 		     const CompRegion &, unsigned int);
+-	void glDecorate (const GLMatrix &, GLFragment::Attrib &,
+-		         const CompRegion &, unsigned int);
++	void glDecorate (const GLMatrix &, const GLWindowPaintAttrib &,
++			 const CompRegion &, unsigned int);
+ 
+ 	void windowNotify (CompWindowNotify n);
+ 
+--- compiz-0.9.7.6.orig/plugins/cube/CMakeLists.txt
++++ compiz-0.9.7.6/plugins/cube/CMakeLists.txt
+@@ -2,4 +2,4 @@ find_package (Compiz REQUIRED)
+ 
+ include (CompizPlugin)
+ 
+-compiz_plugin(cube PLUGINDEPS composite opengl)
+\ No newline at end of file
++#compiz_plugin(cube PLUGINDEPS composite opengl)
+--- compiz-0.9.7.6.orig/plugins/cube/src/cube.cpp
++++ compiz-0.9.7.6/plugins/cube/src/cube.cpp
+@@ -1123,7 +1123,6 @@ CubeScreen::cubePaintTop (const GLScreen
+     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
+     {
+ 	priv->gScreen->setTexEnvMode (GL_MODULATE);
+-	glEnable (GL_BLEND);
+ 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+     }
+ 
+@@ -1149,7 +1148,6 @@ CubeScreen::cubePaintTop (const GLScreen
+     glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+ 
+     priv->gScreen->setTexEnvMode (GL_REPLACE);
+-    glDisable (GL_BLEND);
+     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+ }
+ 
+@@ -1190,7 +1188,6 @@ CubeScreen::cubePaintBottom (const GLScr
+     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
+     {
+ 	priv->gScreen->setTexEnvMode (GL_MODULATE);
+-	glEnable (GL_BLEND);
+ 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+     }
+ 
+@@ -1206,7 +1203,6 @@ CubeScreen::cubePaintBottom (const GLScr
+     glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+ 
+     priv->gScreen->setTexEnvMode (GL_REPLACE);
+-    glDisable (GL_BLEND);
+     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+ }
+ 
+--- compiz-0.9.7.6.orig/plugins/fade/fade.xml.in
++++ compiz-0.9.7.6/plugins/fade/fade.xml.in
+@@ -9,7 +9,6 @@
+ 	    </requirement>
+ 	    <relation type="after">
+ 		<plugin>decor</plugin>
+-		<plugin>staticswitcher</plugin>
+ 	    </relation>
+ 	    <relation type="before">
+ 		<plugin>cube</plugin>
+@@ -50,7 +49,7 @@
+ 	    <option name="window_match" type="match">
+ 		<_short>Fade windows</_short>
+ 		<_long>Windows that should be fading</_long>
+-                <default>any &amp; !(title=notify-osd)</default>
++		<default>any</default>
+ 	    </option>
+ 	    <option name="visual_bell" type="bell">
+ 		<_short>Visual Bell</_short>
+--- compiz-0.9.7.6.orig/plugins/screenshot/src/screenshot.cpp
++++ compiz-0.9.7.6/plugins/screenshot/src/screenshot.cpp
+@@ -249,6 +249,10 @@ ShotScreen::glPaintOutput (const GLScree
+ 			   CompOutput                *output,
+ 			   unsigned int               mask)
+ {
++    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
++    GLMatrix        transform (matrix);
++    GLfloat         vertexData[12];
++    GLushort        colorData[4];
+     bool status;
+ 
+     status = gScreen->glPaintOutput (attrib, matrix, region, output, mask);
+@@ -264,31 +268,54 @@ ShotScreen::glPaintOutput (const GLScree
+ 
+ 	if (mGrabIndex)
+ 	{
+-	    glPushMatrix ();
++	    vertexData[0]  = x1;
++	    vertexData[1]  = y1;
++	    vertexData[2]  = 0.0f;
++	    vertexData[3]  = x1;
++	    vertexData[4]  = y2;
++	    vertexData[5]  = 0.0f;
++	    vertexData[6]  = x2;
++	    vertexData[7]  = y1;
++	    vertexData[8]  = 0.0f;
++	    vertexData[9]  = x2;
++	    vertexData[10] = y2;
++	    vertexData[11] = 0.0f;
++
++	    colorData[0] = 0x2fff;
++	    colorData[1] = 0x2fff;
++	    colorData[2] = 0x4fff;
++	    colorData[3] = 0x4fff;
++
++
++	    transform.translate (-0.5f, -0.5f, -DEFAULT_Z_CAMERA);
++	    transform.scale (1.0f / output->width (),
++	                     -1.0f / output->height (),
++	                     1.0f);
++	    transform.translate (-output->region ()->extents.x1,
++	                         -output->region ()->extents.y2,
++	                         0.0f);
++
++	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
++
++	    streamingBuffer->addColors (1, colorData);
++	    streamingBuffer->addVertices (4, vertexData);
++
++	    streamingBuffer->end ();
++	    streamingBuffer->render (transform);
++
++	    streamingBuffer->begin (GL_LINE_LOOP);
++
++	    vertexData[6]  = x2;
++	    vertexData[7]  = y2;
++	    vertexData[9]  = x2;
++	    vertexData[10] = y1;
++	    colorData [3]  = 0x9fff;
+ 
+-	    glTranslatef (-0.5f, -0.5f, -DEFAULT_Z_CAMERA);
+-	    glScalef (1.0f  / output->width (),
+-	    	      -1.0f / output->height (),
+-	    	      1.0f);
+-	    glTranslatef (-output->region ()->extents.x1,
+-	    		  -output->region ()->extents.y2,
+-	    		  0.0f);
+-
+-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
+-	    glEnable (GL_BLEND);
+-	    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x4fff);
+-	    glRecti (x1, y2, x2, y1);
+-	    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x9fff);
+-	    glBegin (GL_LINE_LOOP);
+-	    glVertex2i (x1, y1);
+-	    glVertex2i (x2, y1);
+-	    glVertex2i (x2, y2);
+-	    glVertex2i (x1, y2);
+-	    glEnd ();
+-	    glColor4usv (defaultColor);
+-	    glDisable (GL_BLEND);
+-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+-	    glPopMatrix ();
++	    streamingBuffer->addColors (1, colorData);
++	    streamingBuffer->addVertices (4, vertexData);
++
++	    streamingBuffer->end ();
++	    streamingBuffer->render (transform);
+ 	}
+     }
+ 
+--- compiz-0.9.7.6.orig/plugins/gnomecompat/gnomecompat.xml.in
++++ compiz-0.9.7.6/plugins/gnomecompat/gnomecompat.xml.in
+@@ -52,7 +52,6 @@
+ 		<option name="run_command_terminal_key" type="key">
+ 		    <_short>Open a terminal</_short>
+ 		    <_long>Open a terminal</_long>
+-		    <default>&lt;Control&gt;&lt;Alt&gt;T</default>
+ 		</option>
+ 	    </group>
+ 	</options>
+--- compiz-0.9.7.6.orig/plugins/place/place.xml.in
++++ compiz-0.9.7.6/plugins/place/place.xml.in
+@@ -19,8 +19,8 @@
+ 	    <option name="mode" type="int">
+ 		<_short>Placement Mode</_short>
+ 		<_long>Algorithm to use for window placement</_long>
+-		<default>2</default>
+-		<min>0</min>
++		<default>0</default>
++		<min>2</min>
+ 		<max>5</max>
+ 		<desc>
+ 		    <value>0</value>
+--- compiz-0.9.7.6.orig/plugins/scale/scale.xml.in
++++ compiz-0.9.7.6/plugins/scale/scale.xml.in
+@@ -18,14 +18,14 @@
+ 			<option name="spacing" type="int">
+ 				<_short>Spacing</_short>
+ 				<_long>Space between windows</_long>
+-				<default>68</default>
++				<default>10</default>
+ 				<min>0</min>
+ 				<max>250</max>
+ 			</option>
+ 			<option name="speed" type="float">
+ 				<_short>Speed</_short>
+ 				<_long>Scale speed</_long>
+-				<default>2.4</default>
++				<default>1.5</default>
+ 				<min>0.1</min>
+ 				<max>50</max>
+ 				<precision>0.1</precision>
+@@ -33,7 +33,7 @@
+ 			<option name="timestep" type="float">
+ 				<_short>Timestep</_short>
+ 				<_long>Scale timestep</_long>
+-				<default>0.1</default>
++				<default>1.2</default>
+ 				<min>0.1</min>
+ 				<max>50</max>
+ 				<precision>0.1</precision>
+@@ -46,7 +46,7 @@
+ 			<option name="opacity" type="int">
+ 				<_short>Opacity</_short>
+ 				<_long>Amount of opacity in percent</_long>
+-				<default>100</default>
++				<default>75</default>
+ 				<min>0</min>
+ 				<max>100</max>
+ 			</option>
+@@ -55,7 +55,7 @@
+ 				<_long>Overlay an icon on windows once they are scaled</_long>
+ 				<min>0</min>
+ 				<max>2</max>
+-				<default>0</default>
++				<default>1</default>
+ 				<desc>
+ 					<value>0</value>
+ 					<_name>None</_name>
+@@ -112,7 +112,7 @@
+ 			<option name="key_bindings_toggle" type="bool">
+ 			    <_short>Key Bindings Toggle Scale Mode</_short>
+ 			    <_long>Key bindings toggle scale mode instead of enabling it when pressed and disabling it when released.</_long>
+-			    <default>true</default>
++			    <default>false</default>
+ 			</option>
+ 			<option name="button_bindings_toggle" type="bool">
+ 			    <_short>Button Bindings Toggle Scale Mode</_short>
+@@ -122,6 +122,9 @@
+ 			<option name="initiate_edge" type="edge">
+ 				<_short>Initiate Window Picker</_short>
+ 				<_long>Layout and start transforming windows</_long>
++				<default>
++				<edge name="TopRight"/>
++				</default>
+ 				<allowed edgednd="true"/>
+ 			</option>
+ 			<option name="initiate_key" type="key">
+@@ -145,7 +148,6 @@
+ 			<option name="initiate_all_key" type="key">
+ 				<_short>Initiate Window Picker For All Windows</_short>
+ 				<_long>Layout and start transforming all windows</_long>
+-				<default>&lt;Super&gt;w</default>
+ 			</option>
+ 			<option name="initiate_group_edge" type="edge">
+ 				<_short>Initiate Window Picker For Window Group</_short>
+@@ -176,7 +178,7 @@
+ 			<option name="show_desktop" type="bool">
+ 				<_short>Click Desktop to Show Desktop</_short>
+ 				<_long>Enter Show Desktop mode when Desktop is clicked during Scale</_long>
+-				<default>false</default>
++				<default>true</default>
+ 			</option>
+ 	    </group>
+ 	</options>
+--- compiz-0.9.7.6.orig/plugins/scale/src/scale.cpp
++++ compiz-0.9.7.6/plugins/scale/src/scale.cpp
+@@ -226,26 +226,19 @@ ScaleWindow::scalePaintDecoration (const
+ 	    GLTexture::MatrixList ml (1);
+ 
+ 	    ml[0] = icon->matrix ();
+-	    priv->gWindow->geometry ().reset ();
++	    priv->gWindow->vertexBuffer ()->begin ();
+ 
+ 	    if (width && height)
+ 		priv->gWindow->glAddGeometry (ml, iconReg, iconReg);
+ 
+-	    if (priv->gWindow->geometry ().vCount)
+-	    {
+-		GLFragment::Attrib fragment (sAttrib);
+-		GLMatrix           wTransform (transform);
++	    priv->gWindow->vertexBuffer ()->end ();
+ 
+-		wTransform.scale (scale, scale, 1.0f);
+-		wTransform.translate (x / scale, y / scale, 0.0f);
+-
+-		glPushMatrix ();
+-		glLoadMatrixf (wTransform.getMatrix ());
++	    GLMatrix           wTransform (transform);
+ 
+-		priv->gWindow->glDrawTexture (icon, fragment, mask);
++	    wTransform.scale (scale, scale, 1.0f);
++	    wTransform.translate (x / scale, y / scale, 0.0f);
+ 
+-		glPopMatrix ();
+-	    }
++	    priv->gWindow->glDrawTexture (icon, wTransform, sAttrib, mask);
+ 	}
+     }
+ }
+@@ -392,13 +385,13 @@ PrivateScaleWindow::glPaint (const GLWin
+ 
+ 	if (scaled)
+ 	{
+-	    GLFragment::Attrib fragment (gWindow->lastPaintAttrib ());
++	    GLWindowPaintAttrib lastAttrib (gWindow->lastPaintAttrib ());
+ 	    GLMatrix           wTransform (transform);
+ 
+ 	    if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
+ 		return false;
+ 
+-	    if (window->alpha () || fragment.getOpacity () != OPAQUE)
++	    if (window->alpha () || lastAttrib.opacity != OPAQUE)
+ 		mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
+ 
+ 	    wTransform.translate (window->x (), window->y (), 0.0f);
+@@ -406,14 +399,9 @@ PrivateScaleWindow::glPaint (const GLWin
+ 	    wTransform.translate (tx / scale - window->x (),
+ 				  ty / scale - window->y (), 0.0f);
+ 
+-	    glPushMatrix ();
+-	    glLoadMatrixf (wTransform.getMatrix ());
+-
+-	    gWindow->glDraw (wTransform, fragment, region,
++	    gWindow->glDraw (wTransform, lastAttrib, region,
+ 			     mask | PAINT_WINDOW_TRANSFORMED_MASK);
+ 
+-	    glPopMatrix ();
+-
+ 	    sWindow->scalePaintDecoration (sAttrib, transform, region, mask);
+ 	}
+     }
+--- compiz-0.9.7.6.orig/plugins/clone/src/clone.cpp
++++ compiz-0.9.7.6/plugins/clone/src/clone.cpp
+@@ -295,9 +295,6 @@ CloneScreen::glPaintOutput (const GLScre
+ 			 0.0f);
+ 	sTransform.scale (zoomX, zoomY, 1.0f);
+ 
+-	glPushMatrix ();
+-	glLoadMatrixf (sTransform.getMatrix ());
+-
+ 	filter = gScreen->textureFilter ();
+ 
+ 	if (offset == 0.0f)
+@@ -325,8 +322,6 @@ CloneScreen::glPaintOutput (const GLScre
+ 	}
+ 
+ 	gScreen->setTextureFilter (filter);
+-
+-	glPopMatrix ();
+     }
+ 
+     return status;
+--- compiz-0.9.7.6.orig/plugins/opengl/compiz-opengl.pc.in
++++ compiz-0.9.7.6/plugins/opengl/compiz-opengl.pc.in
+@@ -8,5 +8,5 @@ Description: Opengl compositing plugin f
+ Version: @VERSION@
+ 
+ Requires: compiz compiz-composite
+-Libs: -lGL -L${libdir} -lopengl
+-Cflags: @COMPIZ_CFLAGS@ -I${includedir}/compiz
+\ No newline at end of file
++Libs: @PKGCONFIG_LIBS@ -L${libdir} -lopengl
++Cflags: @COMPIZ_CFLAGS@ -I${includedir}/compiz
+--- compiz-0.9.7.6.orig/plugins/opengl/opengl.xml.in
++++ compiz-0.9.7.6/plugins/opengl/opengl.xml.in
+@@ -36,7 +36,7 @@
+ 	    <option name="sync_to_vblank" type="bool">
+ 		<_short>Sync To VBlank</_short>
+ 		<_long>Only perform screen updates during vertical blanking period</_long>
+-		<default>true</default>
++		<default>false</default>
+ 	    </option>
+ 	    <option name="texture_compression" type="bool">
+ 		<_short>Texture Compression</_short>
+--- compiz-0.9.7.6.orig/plugins/opengl/CMakeLists.txt
++++ compiz-0.9.7.6/plugins/opengl/CMakeLists.txt
+@@ -2,7 +2,12 @@ find_package (Compiz REQUIRED)
+ 
+ include (CompizPlugin)
+ 
+-find_package (OpenGL)
+-if (OPENGL_FOUND)
+-    compiz_plugin(opengl PLUGINDEPS composite LIBRARIES ${OPENGL_gl_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
+-endif ()
+\ No newline at end of file
++if (USE_GLES)
++    compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD "-DUSE_GLES -std=c++0x" LIBRARIES ${OPENGLES2_LIBRARIES} INCDIRS ${OPENGLES2_INCLUDE_DIR})
++else (USE_GLES)
++    find_package (OpenGL)
++    if (OPENGL_FOUND)
++	compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD -std=c++0x LIBRARIES ${OPENGL_gl_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
++    endif (OPENGL_FOUND)
++endif (USE_GLES)
++
+--- compiz-0.9.7.6.orig/plugins/opengl/src/screen.cpp
++++ compiz-0.9.7.6/plugins/opengl/src/screen.cpp
+@@ -1,4 +1,5 @@
+ /*
++ * Copyright © 2011 Linaro Ltd.
+  * Copyright © 2008 Dennis Kasprzyk
+  * Copyright © 2007 Novell, Inc.
+  *
+@@ -23,6 +24,7 @@
+  *
+  * Authors: Dennis Kasprzyk <[e-mail]>
+  *          David Reveman <[e-mail]>
++ *          Travis Watkins <[e-mail]>
+  */
+ 
+ #ifndef _GNU_SOURCE
+@@ -36,6 +38,18 @@
+ #include <math.h>
+ 
+ namespace GL {
++    #ifdef USE_GLES
++    EGLCreateImageKHRProc  createImage;
++    EGLDestroyImageKHRProc destroyImage;
++
++    GLEGLImageTargetTexture2DOESProc eglImageTargetTexture;
++
++    EGLPostSubBufferNVProc postSubBuffer = NULL;
++    #else
++
++    typedef int (*GLXSwapIntervalProc) (int interval);
++
++    GLXSwapIntervalProc      swapInterval = NULL;
+     GLXBindTexImageProc      bindTexImage = NULL;
+     GLXReleaseTexImageProc   releaseTexImage = NULL;
+     GLXQueryDrawableProc     queryDrawable = NULL;
+@@ -47,18 +61,17 @@ namespace GL {
+     GLXGetFBConfigAttribProc getFBConfigAttrib = NULL;
+     GLXCreatePixmapProc      createPixmap = NULL;
+     GLXDestroyPixmapProc     destroyPixmap = NULL;
+-
+-    GLActiveTextureProc       activeTexture = NULL;
+-    GLClientActiveTextureProc clientActiveTexture = NULL;
+-    GLMultiTexCoord2fProc     multiTexCoord2f = NULL;
+-
+     GLGenProgramsProc	     genPrograms = NULL;
+     GLDeleteProgramsProc     deletePrograms = NULL;
+     GLBindProgramProc	     bindProgram = NULL;
+     GLProgramStringProc	     programString = NULL;
+     GLProgramParameter4fProc programEnvParameter4f = NULL;
+     GLProgramParameter4fProc programLocalParameter4f = NULL;
+-    GLGetProgramivProc       getProgramiv = NULL;
++    #endif
++
++    GLActiveTextureProc       activeTexture = NULL;
++    GLClientActiveTextureProc clientActiveTexture = NULL;
++    GLMultiTexCoord2fProc     multiTexCoord2f = NULL;
+ 
+     GLGenFramebuffersProc        genFramebuffers = NULL;
+     GLDeleteFramebuffersProc     deleteFramebuffers = NULL;
+@@ -67,16 +80,54 @@ namespace GL {
+     GLFramebufferTexture2DProc   framebufferTexture2D = NULL;
+     GLGenerateMipmapProc         generateMipmap = NULL;
+ 
++    GLBindBufferProc    bindBuffer = NULL;
++    GLDeleteBuffersProc deleteBuffers = NULL;
++    GLGenBuffersProc    genBuffers = NULL;
++    GLBufferDataProc    bufferData = NULL;
++    GLBufferSubDataProc bufferSubData = NULL;
++
++    GLGetShaderivProc        getShaderiv = NULL;
++    GLGetShaderInfoLogProc   getShaderInfoLog = NULL;
++    GLGetProgramivProc       getProgramiv = NULL;
++    GLGetProgramInfoLogProc  getProgramInfoLog = NULL;
++    GLCreateShaderProc       createShader = NULL;
++    GLShaderSourceProc       shaderSource = NULL;
++    GLCompileShaderProc      compileShader = NULL;
++    GLCreateProgramProc      createProgram = NULL;
++    GLAttachShaderProc       attachShader = NULL;
++    GLLinkProgramProc        linkProgram = NULL;
++    GLValidateProgramProc    validateProgram = NULL;
++    GLDeleteShaderProc       deleteShader = NULL;
++    GLDeleteProgramProc      deleteProgram = NULL;
++    GLUseProgramProc         useProgram = NULL;
++    GLGetUniformLocationProc getUniformLocation = NULL;
++    GLUniform1fProc          uniform1f = NULL;
++    GLUniform1iProc          uniform1i = NULL;
++    GLUniform2fProc          uniform2f = NULL;
++    GLUniform2iProc          uniform2i = NULL;
++    GLUniform3fProc          uniform3f = NULL;
++    GLUniform3iProc          uniform3i = NULL;
++    GLUniform4fProc          uniform4f = NULL;
++    GLUniform4iProc          uniform4i = NULL;
++    GLUniformMatrix4fvProc   uniformMatrix4fv = NULL;
++    GLGetAttribLocationProc  getAttribLocation = NULL;
++
++    GLEnableVertexAttribArrayProc  enableVertexAttribArray = NULL;
++    GLDisableVertexAttribArrayProc disableVertexAttribArray = NULL;
++    GLVertexAttribPointerProc      vertexAttribPointer = NULL;
++
+     bool  textureFromPixmap = true;
+     bool  textureRectangle = false;
+     bool  textureNonPowerOfTwo = false;
++    bool  textureNonPowerOfTwoMipmap = false;
+     bool  textureEnvCombine = false;
+     bool  textureEnvCrossbar = false;
+     bool  textureBorderClamp = false;
+     bool  textureCompression = false;
+     GLint maxTextureSize = 0;
+     bool  fbo = false;
+-    bool  fragmentProgram = false;
++    bool  vbo = false;
++    bool  shaders = false;
+     GLint maxTextureUnits = 1;
+ 
+     bool canDoSaturated = false;
+@@ -88,24 +139,234 @@ namespace GL {
+ 
+ CompOutput *targetOutput = NULL;
+ 
+-class DetectionWorkaround
++/**
++ * Callback object to create GLPrograms automatically when using GLVertexBuffer.
++ */
++class GLScreenAutoProgram : public GLVertexBuffer::AutoProgram
+ {
+-    public:
++public:
++    GLScreenAutoProgram (GLScreen *gScreen) : gScreen(gScreen) {}
+ 
+-        DetectionWorkaround ()
+-        {
+-            program_invocation_short_name[0] = 'C';
+-        }
+-        ~DetectionWorkaround ()
+-        {
+-            program_invocation_short_name[0] = 'c';
+-        }
++    GLProgram *getProgram (GLShaderParameters &params)
++    {
++        const GLShaderData *shaderData = gScreen->getShaderData (params);
++        std::list<const GLShaderData *> tempShaders;
++        tempShaders.push_back (shaderData);
++        return gScreen->getProgram (tempShaders);
++    }
++
++    GLScreen *gScreen;
+ };
+ 
+ bool
+ GLScreen::glInitContext (XVisualInfo *visinfo)
+ {
+-    DetectionWorkaround workaround;
++    #ifdef USE_GLES
++    Display             *xdpy;
++    Window               overlay;
++    EGLDisplay           dpy;
++    EGLConfig            config;
++    EGLint               major, minor;
++    const char		*eglExtensions, *glExtensions;
++    XWindowAttributes    attr;
++    EGLint               count, visualid;
++    EGLConfig            configs[1024];
++    CompOption::Vector   o (0);
++
++    const EGLint config_attribs[] = {
++	EGL_SURFACE_TYPE,         EGL_WINDOW_BIT,
++	EGL_RED_SIZE,             1,
++	EGL_GREEN_SIZE,           1,
++	EGL_BLUE_SIZE,            1,
++	EGL_ALPHA_SIZE,           0,
++	EGL_RENDERABLE_TYPE,      EGL_OPENGL_ES2_BIT,
++	EGL_CONFIG_CAVEAT,        EGL_NONE,
++	EGL_NONE,
++    };
++
++    const EGLint context_attribs[] = {
++        EGL_CONTEXT_CLIENT_VERSION, 2,
++        EGL_NONE
++    };
++
++    xdpy = screen->dpy ();
++    dpy = eglGetDisplay ((EGLNativeDisplayType)xdpy);
++    if (!eglInitialize (dpy, &major, &minor))
++    {
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    eglBindAPI (EGL_OPENGL_ES_API);
++
++    if (!eglChooseConfig (dpy, config_attribs, configs, 1024, &count))
++    {
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    if (!XGetWindowAttributes (xdpy, screen->root (), &attr))
++    {
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    visualid = XVisualIDFromVisual (attr.visual);
++    config = configs[0];
++    for (int i = 0; i < count; i++) {
++        EGLint val;
++        eglGetConfigAttrib (dpy, configs[i], EGL_NATIVE_VISUAL_ID, &val);
++        if (visualid == val) {
++            config = configs[i];
++            break;
++        }
++    }
++
++    overlay = CompositeScreen::get (screen)->overlay ();
++    priv->surface = eglCreateWindowSurface (dpy, config, overlay, 0);
++    if (priv->surface == EGL_NO_SURFACE)
++    {
++	compLogMessage ("opengl", CompLogLevelFatal,
++	                "eglCreateWindowSurface failed");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    // Currently we rely unconditionally on preserving the buffer contents.
++    eglSurfaceAttrib (dpy, priv->surface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
++
++    priv->ctx = eglCreateContext (dpy, config, EGL_NO_CONTEXT, context_attribs);
++    if (priv->ctx == EGL_NO_CONTEXT)
++    {
++	compLogMessage ("opengl", CompLogLevelFatal, "eglCreateContext failed");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    if (!eglMakeCurrent (dpy, priv->surface, priv->surface, priv->ctx))
++    {
++	compLogMessage ("opengl", CompLogLevelFatal,
++	                "eglMakeCurrent failed");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    eglExtensions = (const char *) eglQueryString (dpy, EGL_EXTENSIONS);
++    glExtensions = (const char *) glGetString (GL_EXTENSIONS);
++
++    if (!glExtensions || !eglExtensions)
++    {
++	compLogMessage ("opengl", CompLogLevelFatal,
++			"No valid GL extensions string found.");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++    GL::textureFromPixmap = true;
++    GL::textureNonPowerOfTwo = true;
++    GL::fbo = true;
++    GL::vbo = true;
++    GL::shaders = true;
++    GL::maxTextureUnits = 4;
++    glGetIntegerv (GL_MAX_TEXTURE_SIZE, &GL::maxTextureSize);
++
++    GL::createImage = (GL::EGLCreateImageKHRProc)
++	eglGetProcAddress ("eglCreateImageKHR");
++    GL::destroyImage = (GL::EGLDestroyImageKHRProc)
++	eglGetProcAddress ("eglDestroyImageKHR");
++    GL::eglImageTargetTexture = (GL::GLEGLImageTargetTexture2DOESProc)
++	eglGetProcAddress ("glEGLImageTargetTexture2DOES");
++
++    if (!strstr (eglExtensions, "EGL_KHR_image_pixmap") ||
++        !strstr (glExtensions, "GL_OES_EGL_image") ||
++	!GL::createImage || !GL::destroyImage || !GL::eglImageTargetTexture)
++    {
++	compLogMessage ("opengl", CompLogLevelFatal,
++			"GL_OES_EGL_image is missing");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++
++// work around efika supporting GL_BGRA directly instead of via this extension
++#ifndef GL_BGRA
++    if (!strstr (glExtensions, "GL_EXT_texture_format_BGRA8888"))
++    {
++	compLogMessage ("opengl", CompLogLevelFatal,
++			"GL_EXT_texture_format_BGRA8888 is missing");
++	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
++	return false;
++    }
++#endif
++
++    if (strstr (glExtensions, "GL_OES_texture_npot"))
++	GL::textureNonPowerOfTwoMipmap = true;
++
++    if (strstr (eglExtensions, "EGL_NV_post_sub_buffer"))
++	GL::postSubBuffer = (GL::EGLPostSubBufferNVProc)
++	    eglGetProcAddress ("eglPostSubBufferNV");
++
++    GL::activeTexture = glActiveTexture;
++    GL::genFramebuffers = glGenFramebuffers;
++    GL::deleteFramebuffers = glDeleteFramebuffers;
++    GL::bindFramebuffer = glBindFramebuffer;
++    GL::checkFramebufferStatus = glCheckFramebufferStatus;
++    GL::framebufferTexture2D = glFramebufferTexture2D;
++    GL::generateMipmap = glGenerateMipmap;
++
++    GL::bindBuffer = glBindBuffer;
++    GL::deleteBuffers = glDeleteBuffers;
++    GL::genBuffers = glGenBuffers;
++    GL::bufferData = glBufferData;
++    GL::bufferSubData = glBufferSubData;
++
++    GL::getShaderiv = glGetShaderiv;
++    GL::getShaderInfoLog = glGetShaderInfoLog;
++    GL::getProgramiv = glGetProgramiv;
++    GL::getProgramInfoLog = glGetProgramInfoLog;
++    GL::createShader = glCreateShader;
++    GL::shaderSource = glShaderSource;
++    GL::compileShader = glCompileShader;
++    GL::createProgram = glCreateProgram;
++    GL::attachShader = glAttachShader;
++    GL::linkProgram = glLinkProgram;
++    GL::validateProgram = glValidateProgram;
++    GL::deleteShader = glDeleteShader;
++    GL::deleteProgram = glDeleteProgram;
++    GL::useProgram = glUseProgram;
++    GL::getUniformLocation = glGetUniformLocation;
++    GL::uniform1f = glUniform1f;
++    GL::uniform1i = glUniform1i;
++    GL::uniform2f = glUniform2f;
++    GL::uniform2i = glUniform2i;
++    GL::uniform3f = glUniform3f;
++    GL::uniform3i = glUniform3i;
++    GL::uniform4f = glUniform4f;
++    GL::uniform4i = glUniform4i;
++    GL::uniformMatrix4fv = glUniformMatrix4fv;
++    GL::getAttribLocation = glGetAttribLocation;
++
++    GL::enableVertexAttribArray = glEnableVertexAttribArray;
++    GL::disableVertexAttribArray = glDisableVertexAttribArray;
++    GL::vertexAttribPointer = glVertexAttribPointer;
++
++    glClearColor (0.0, 0.0, 0.0, 1.0);
++    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
++    glEnable (GL_BLEND);
++    glEnable (GL_CULL_FACE);
++
++    priv->updateView ();
++
++    priv->lighting = false;
++
++    priv->filter[NOTHING_TRANS_FILTER] = GLTexture::Fast;
++    priv->filter[SCREEN_TRANS_FILTER]  = GLTexture::Good;
++    priv->filter[WINDOW_TRANS_FILTER]  = GLTexture::Good;
++
++    if (GL::textureFromPixmap)
++	registerBindPixmap (EglTexture::bindPixmapToTexture);
++
++    #else
++
+     Display		 *dpy = screen->dpy ();
+     const char		 *glExtensions;
+     GLfloat		 globalAmbient[]  = { 0.1f, 0.1f,  0.1f, 0.1f };
+@@ -165,6 +426,7 @@ GLScreen::glInitContext (XVisualInfo *vi
+ 
+     if (strstr (glExtensions, "GL_ARB_texture_non_power_of_two"))
+ 	GL::textureNonPowerOfTwo = true;
++    GL::textureNonPowerOfTwoMipmap = GL::textureNonPowerOfTwo;
+ 
+     glGetIntegerv (GL_MAX_TEXTURE_SIZE, &GL::maxTextureSize);
+ 
+@@ -221,33 +483,6 @@ GLScreen::glInitContext (XVisualInfo *vi
+ 	    glGetIntegerv (GL_MAX_TEXTURE_UNITS_ARB, &GL::maxTextureUnits);
+     }
+ 
+-    if (strstr (glExtensions, "GL_ARB_fragment_program"))
+-    {
+-	GL::genPrograms = (GL::GLGenProgramsProc)
+-	    getProcAddress ("glGenProgramsARB");
+-	GL::deletePrograms = (GL::GLDeleteProgramsProc)
+-	    getProcAddress ("glDeleteProgramsARB");
+-	GL::bindProgram = (GL::GLBindProgramProc)
+-	    getProcAddress ("glBindProgramARB");
+-	GL::programString = (GL::GLProgramStringProc)
+-	    getProcAddress ("glProgramStringARB");
+-	GL::programEnvParameter4f = (GL::GLProgramParameter4fProc)
+-	    getProcAddress ("glProgramEnvParameter4fARB");
+-	GL::programLocalParameter4f = (GL::GLProgramParameter4fProc)
+-	    getProcAddress ("glProgramLocalParameter4fARB");
+-	GL::getProgramiv = (GL::GLGetProgramivProc)
+-	    getProcAddress ("glGetProgramivARB");
+-
+-	if (GL::genPrograms             &&
+-	    GL::deletePrograms          &&
+-	    GL::bindProgram             &&
+-	    GL::programString           &&
+-	    GL::programEnvParameter4f   &&
+-	    GL::programLocalParameter4f &&
+-	    GL::getProgramiv)
+-	    GL::fragmentProgram = true;
+-    }
+-
+     if (strstr (glExtensions, "GL_EXT_framebuffer_object"))
+     {
+ 	GL::genFramebuffers = (GL::GLGenFramebuffersProc)
+@@ -272,6 +507,63 @@ GLScreen::glInitContext (XVisualInfo *vi
+ 	    GL::fbo = true;
+     }
+ 
++    if (strstr (glExtensions, "GL_ARB_vertex_buffer_object"))
++    {
++	GL::bindBuffer = (GL::GLBindBufferProc)
++	    getProcAddress ("glBindBufferARB");
++	GL::deleteBuffers = (GL::GLDeleteBuffersProc)
++	    getProcAddress ("glDeleteBuffersARB");
++	GL::genBuffers = (GL::GLGenBuffersProc)
++	    getProcAddress ("glGenBuffersARB");
++	GL::bufferData = (GL::GLBufferDataProc)
++	    getProcAddress ("glBufferDataARB");
++	GL::bufferSubData = (GL::GLBufferSubDataProc)
++	    getProcAddress ("glBufferSubDataARB");
++
++	if (GL::bindBuffer    &&
++	    GL::deleteBuffers &&
++	    GL::genBuffers    &&
++	    GL::bufferData    &&
++	    GL::bufferSubData)
++	    GL::vbo = true;
++    }
++
++    if (strstr (glExtensions, "GL_ARB_fragment_shader") &&
++        strstr (glExtensions, "GL_ARB_vertex_shader"))
++    {
++	GL::getShaderiv = (GL::GLGetShaderivProc) getProcAddress ("glGetShaderiv");
++	GL::getShaderInfoLog = (GL::GLGetShaderInfoLogProc) getProcAddress ("glGetShaderInfoLog");
++	GL::getProgramiv = (GL::GLGetProgramivProc) getProcAddress ("glGetProgramiv");
++	GL::getProgramInfoLog = (GL::GLGetProgramInfoLogProc) getProcAddress ("glGetProgramInfoLog");
++	GL::createShader = (GL::GLCreateShaderProc) getProcAddress ("glCreateShader");
++	GL::shaderSource = (GL::GLShaderSourceProc) getProcAddress ("glShaderSource");
++	GL::compileShader = (GL::GLCompileShaderProc) getProcAddress ("glCompileShader");
++	GL::createProgram = (GL::GLCreateProgramProc) getProcAddress ("glCreateProgram");
++	GL::attachShader = (GL::GLAttachShaderProc) getProcAddress ("glAttachShader");
++	GL::linkProgram = (GL::GLLinkProgramProc) getProcAddress ("glLinkProgram");
++	GL::validateProgram = (GL::GLValidateProgramProc) getProcAddress ("glValidateProgram");
++	GL::deleteShader = (GL::GLDeleteShaderProc) getProcAddress ("glDeleteShader");
++	GL::deleteProgram = (GL::GLDeleteProgramProc) getProcAddress ("glDeleteProgram");
++	GL::useProgram = (GL::GLUseProgramProc) getProcAddress ("glUseProgram");
++	GL::getUniformLocation = (GL::GLGetUniformLocationProc) getProcAddress ("glGetUniformLocation");
++	GL::uniform1f = (GL::GLUniform1fProc) getProcAddress ("glUniform1f");
++	GL::uniform1i = (GL::GLUniform1iProc) getProcAddress ("glUniform1i");
++	GL::uniform2f = (GL::GLUniform2fProc) getProcAddress ("glUniform2f");
++	GL::uniform2i = (GL::GLUniform2iProc) getProcAddress ("glUniform2i");
++	GL::uniform3f = (GL::GLUniform3fProc) getProcAddress ("glUniform3f");
++	GL::uniform3i = (GL::GLUniform3iProc) getProcAddress ("glUniform3i");
++	GL::uniform4f = (GL::GLUniform4fProc) getProcAddress ("glUniform4f");
++	GL::uniform4i = (GL::GLUniform4iProc) getProcAddress ("glUniform4i");
++	GL::uniformMatrix4fv = (GL::GLUniformMatrix4fvProc) getProcAddress ("glUniformMatrix4fv");
++	GL::getAttribLocation = (GL::GLGetAttribLocationProc) getProcAddress ("glGetAttribLocation");
++
++	GL::enableVertexAttribArray = (GL::GLEnableVertexAttribArrayProc) getProcAddress ("glEnableVertexAttribArray");
++	GL::disableVertexAttribArray = (GL::GLDisableVertexAttribArrayProc) getProcAddress ("glDisableVertexAttribArray");
++	GL::vertexAttribPointer = (GL::GLVertexAttribPointerProc) getProcAddress ("glVertexAttribPointer");
++
++	GL::shaders = true;
++    }
++
+     if (strstr (glExtensions, "GL_ARB_texture_compression"))
+ 	GL::textureCompression = true;
+ 
+@@ -313,6 +605,12 @@ GLScreen::glInitContext (XVisualInfo *vi
+ 
+     if (GL::textureFromPixmap)
+ 	registerBindPixmap (TfpTexture::bindPixmapToTexture);
++#endif
++
++    priv->scratchFbo = new GLFramebufferObject;
++    priv->scratchFbo->allocate (*screen, NULL, GL_BGRA);
++
++    GLVertexBuffer::streamingBuffer ()->setAutoProgram (priv->autoProgram);
+ 
+     return true;
+ }
+@@ -322,14 +620,14 @@ GLScreen::GLScreen (CompScreen *s) :
+     PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI> (s),
+     priv (new PrivateGLScreen (this))
+ {
++    XVisualInfo		 *visinfo = NULL;
++#ifndef USE_GLES
+     Display		 *dpy = s->dpy ();
+     XVisualInfo		 templ;
+-    XVisualInfo		 *visinfo;
+     GLXFBConfig		 *fbConfigs;
+     int			 defaultDepth, nvisinfo, nElements, value, i;
+     const char		 *glxExtensions;
+     XWindowAttributes    attr;
+-    DetectionWorkaround workaround;
+     CompOption::Vector o (0);
+ 
+     if (!XGetWindowAttributes (dpy, s->root (), &attr))
+@@ -574,6 +872,7 @@ GLScreen::GLScreen (CompScreen *s) :
+ 	setFailed ();
+     }
+ 
++#endif
+     if (!glInitContext (visinfo))
+ 	setFailed ();
+ }
+@@ -582,7 +881,22 @@ GLScreen::~GLScreen ()
+ {
+     if (priv->hasCompositing)
+ 	CompositeScreen::get (screen)->unregisterPaintHandler ();
++
++    #ifdef USE_GLES
++    Display *xdpy = screen->dpy ();
++    EGLDisplay dpy = eglGetDisplay (xdpy);
++
++    eglMakeCurrent (dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
++    eglDestroyContext (dpy, priv->ctx);
++    eglDestroySurface (dpy, priv->surface);
++    eglTerminate (dpy);
++    eglReleaseThread ();
++    #else
++
+     glXDestroyContext (screen->dpy (), priv->ctx);
++    #endif
++
++    delete priv->scratchFbo;
+     delete priv;
+ }
+ 
+@@ -593,14 +907,21 @@ PrivateGLScreen::PrivateGLScreen (GLScre
+     backgroundTextures (),
+     backgroundLoaded (false),
+     rasterPos (0, 0),
+-    fragmentStorage (),
++    projection (NULL),
+     clearBuffers (true),
+     lighting (false),
++    #ifndef USE_GLES
+     getProcAddress (0),
++    #endif
++    scratchFbo (NULL),
+     outputRegion (),
+     pendingCommands (false),
++    lastMask (0),
+     bindPixmap (),
+     hasCompositing (false),
++    programCache (new GLProgramCache (30)),
++    shaderCache (),
++    autoProgram (new GLScreenAutoProgram(gs)),
+     rootPixmapCopy (None),
+     rootPixmapSize ()
+ {
+@@ -609,6 +930,8 @@ PrivateGLScreen::PrivateGLScreen (GLScre
+ 
+ PrivateGLScreen::~PrivateGLScreen ()
+ {
++    delete programCache;
++    delete autoProgram;
+     if (rootPixmapCopy)
+ 	XFreePixmap (screen->dpy (), rootPixmapCopy);
+ 
+@@ -670,8 +993,13 @@ PrivateGLScreen::handleEvent (XEvent *ev
+ 	    {
+ 		XDamageNotifyEvent *de = (XDamageNotifyEvent *) event;
+ 
++		#ifdef USE_GLES
++		std::map<Damage, EglTexture*>::iterator it =
++		    boundPixmapTex.find (de->damage);
++		#else
+ 		std::map<Damage, TfpTexture*>::iterator it =
+ 		    boundPixmapTex.find (de->damage);
++		#endif
+ 		if (it != boundPixmapTex.end ())
+ 		{
+ 		    it->second->damaged = true;
+@@ -743,22 +1071,32 @@ perspective (GLfloat *m,
+ void
+ PrivateGLScreen::updateView ()
+ {
++    GLfloat projection_array[16];
++
++    #ifndef USE_GLES
+     glMatrixMode (GL_PROJECTION);
+     glLoadIdentity ();
+     glMatrixMode (GL_MODELVIEW);
+     glLoadIdentity ();
+     glDepthRange (0, 1);
+-    glViewport (-1, -1, 2, 2);
+     glRasterPos2f (0, 0);
++    #endif
++    glViewport (-1, -1, 2, 2);
+ 
+     rasterPos = CompPoint (0, 0);
+ 
+-    perspective (projection, 60.0f, 1.0f, 0.1f, 100.0f);
++    perspective (projection_array, 60.0f, 1.0f, 0.1f, 100.0f);
++
++    if (projection != NULL)
++	delete projection;
++    projection = new GLMatrix (projection_array);
+ 
++    #ifndef USE_GLES
+     glMatrixMode (GL_PROJECTION);
+     glLoadIdentity ();
+-    glMultMatrixf (projection);
++    glMultMatrixf (projection_array);
+     glMatrixMode (GL_MODELVIEW);
++    #endif
+ 
+     CompRegion region (screen->region ());
+     /* remove all output regions from visible screen region */
+@@ -777,9 +1115,11 @@ PrivateGLScreen::outputChangeNotify ()
+ {
+     screen->outputChangeNotify ();
+ 
++    scratchFbo->allocate (*screen, NULL, GL_BGRA);
+     updateView ();
+ }
+ 
++#ifndef USE_GLES
+ GL::FuncPtr
+ GLScreen::getProcAddress (const char *name)
+ {
+@@ -805,6 +1145,7 @@ GLScreen::getProcAddress (const char *na
+ 
+     return funcPtr;
+ }
++#endif
+ 
+ void
+ PrivateGLScreen::updateScreenBackground ()
+@@ -922,32 +1263,23 @@ PrivateGLScreen::updateScreenBackground
+ 
+ 	XFreeGC(dpy, gc);
+     }
+-
+-    if (!backgroundTextures.empty ())
+-    {
+-	foreach (GLTexture *t, backgroundTextures)
+-	    if (t->target () == GL_TEXTURE_2D)
+-	    {
+-		glBindTexture (t->target (), t->name ());
+-		glTexParameteri (t->target (), GL_TEXTURE_WRAP_S, GL_REPEAT);
+-		glTexParameteri (t->target (), GL_TEXTURE_WRAP_T, GL_REPEAT);
+-		glBindTexture (t->target (), 0);
+-	    }
+-    }
+ }
+ 
+ void
+ GLScreen::setTexEnvMode (GLenum mode)
+ {
++    #ifndef USE_GLES
+     if (priv->lighting)
+ 	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+     else
+ 	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode);
++    #endif
+ }
+ 
+ void
+ GLScreen::setLighting (bool lighting)
+ {
++    #ifndef USE_GLES
+     if (priv->lighting != lighting)
+     {
+ 	if (!priv->optionGetLighting ())
+@@ -968,6 +1300,7 @@ GLScreen::setLighting (bool lighting)
+ 
+ 	setTexEnvMode (GL_REPLACE);
+     }
++    #endif
+ }
+ 
+ bool
+@@ -1003,6 +1336,25 @@ void
+ GLScreenInterface::glDisableOutputClipping ()
+     WRAPABLE_DEF (glDisableOutputClipping)
+ 
++GLMatrix *
++GLScreenInterface::projectionMatrix ()
++    WRAPABLE_DEF (projectionMatrix)
++
++void
++GLScreenInterface::glPaintCompositedOutput (const CompRegion    &region,
++					    GLFramebufferObject *fbo,
++					    unsigned int         mask)
++    WRAPABLE_DEF (glPaintCompositedOutput, region, fbo, mask)
++
++
++GLMatrix *
++GLScreen::projectionMatrix ()
++{
++    WRAPABLE_HND_FUNCTN_RETURN (GLMatrix *, projectionMatrix)
++
++    return priv->projection;
++}
++
+ void
+ GLScreen::updateBackground ()
+ {
+@@ -1033,17 +1385,13 @@ GLScreen::setFilter (int num, GLTexture:
+     priv->filter[num] = filter;
+ }
+ 
+-GLFragment::Storage *
+-GLScreen::fragmentStorage ()
+-{
+-    return &priv->fragmentStorage;
+-}
+-
++#ifndef USE_GLES
+ GLFBConfig*
+ GLScreen::glxPixmapFBConfig (unsigned int depth)
+ {
+     return &priv->glxPixmapFBConfigs[depth];
+ }
++#endif
+ 
+ void
+ GLScreen::clearOutput (CompOutput   *output,
+@@ -1056,16 +1404,13 @@ GLScreen::clearOutput (CompOutput   *out
+ 	pBox->x2 != (int) screen->width () ||
+ 	pBox->y2 != (int) screen->height ())
+     {
+-	glPushAttrib (GL_SCISSOR_BIT);
+-
+ 	glEnable (GL_SCISSOR_TEST);
+ 	glScissor (pBox->x1,
+ 		   screen->height () - pBox->y2,
+ 		   pBox->x2 - pBox->x1,
+ 		   pBox->y2 - pBox->y1);
+ 	glClear (mask);
+-
+-	glPopAttrib ();
++	glDisable (GL_SCISSOR_TEST);
+     }
+     else
+     {
+@@ -1088,12 +1433,33 @@ GLScreen::setDefaultViewport ()
+ 		priv->lastViewport.height);
+ }
+ 
++#ifdef USE_GLES
++EGLContext
++GLScreen::getEGLContext ()
++{
++    return priv->ctx;
++}
++#endif
++
++GLProgram *
++GLScreen::getProgram (std::list<const GLShaderData*> shaders)
++{
++    return (*priv->programCache)(shaders);
++}
++
++const GLShaderData *
++GLScreen::getShaderData (GLShaderParameters &params)
++{
++    return &priv->shaderCache.getShaderData(params);
++}
++
+ namespace GL
+ {
+ 
+ void
+ waitForVideoSync ()
+ {
++#ifndef USE_GLES
+     GL::unthrottledFrames++;
+     if (GL::waitVideoSync)
+     {
+@@ -1118,11 +1484,13 @@ waitForVideoSync ()
+ 	if (GL::vsyncCount != oldCount)
+ 	    GL::unthrottledFrames = 0;
+     }
++#endif
+ }
+ 
+ void
+ controlSwapVideoSync (bool sync)
+ {
++#ifndef USE_GLES
+     // Docs: http://www.opengl.org/registry/specs/SGI/swap_control.txt
+     if (GL::swapInterval)
+     {
+@@ -1131,6 +1499,7 @@ controlSwapVideoSync (bool sync)
+     }
+     else if (sync)
+ 	waitForVideoSync ();
++#endif
+ }
+ 
+ } // namespace GL
+@@ -1149,6 +1518,35 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ {
+     XRectangle r;
+ 
++    // Blending is disabled by default. Each operation/plugin
++    // should enable it (and reset it) as needed.
++    glDisable(GL_BLEND);
++
++    GLFramebufferObject *oldFbo = NULL;
++    bool useFbo = false;
++
++    oldFbo = scratchFbo->bind ();
++    useFbo = scratchFbo->checkStatus () && scratchFbo->tex ();
++    if (!useFbo) {
++printf ("bailing!");
++	GLFramebufferObject::rebind (oldFbo);
++    }
++
++    refreshSubBuffer = ((lastMask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
++                        !(mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK) &&
++                        (mask & COMPOSITE_SCREEN_DAMAGE_REGION_MASK));
++
++    if (refreshSubBuffer)
++    {
++	// FIXME: We shouldn't have to substract a 1X1 pixel region here !!
++	// This is an ugly workaround for what appears to be a bug in the SGX
++	// X11 driver (e.g. on Pandaboard OMAP4 platform).
++	// Posting a fullscreen damage region to the SGX seems to reset the
++	// framebuffer, causing the screen to blackout.
++	cScreen->damageRegion (CompRegion (screen->fullscreenOutput ()) -
++                               CompRegion (CompRect(0, 0, 1, 1)));
++    }
++
+     if (clearBuffers)
+     {
+ 	if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
+@@ -1175,7 +1573,11 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 	    lastViewport = r;
+ 	}
+ 
++#ifdef USE_GLES
++	if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK || !GL::postSubBuffer)
++#else
+ 	if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
++#endif
+ 	{
+ 	    GLMatrix identity;
+ 
+@@ -1189,6 +1591,9 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 	{
+ 	    GLMatrix identity;
+ 
++	    if (refreshSubBuffer)
++		tmpRegion = CompRegion (*output);
++
+ 	    outputRegion = tmpRegion & CompRegion (*output);
+ 
+ 	    if (!gScreen->glPaintOutput (defaultScreenPaintAttrib,
+@@ -1204,15 +1609,38 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 					PAINT_SCREEN_FULL_MASK);
+ 
+ 		tmpRegion += *output;
+-
+ 	    }
+ 	}
+     }
+ 
+     targetOutput = &screen->outputDevs ()[0];
++    glFlush ();
+ 
+-    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
++    if (useFbo)
+     {
++	GLFramebufferObject::rebind (oldFbo);
++
++	// FIXME: does not work if screen dimensions exceed max texture size
++	gScreen->glPaintCompositedOutput (tmpRegion, scratchFbo, mask);
++    }
++
++    // FIXME: Actually fix the composite plugin to be more efficient;
++    // If GL::swapInterval == NULL && GL::waitVideoSync != NULL then the
++    // composite plugin should not be imposing any framerate restriction
++    // (ie. blocking the CPU) at all. Because the framerate will be controlled
++    // and optimized here:
++#ifdef USE_GLES
++    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK || !GL::postSubBuffer)
++#else
++    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
++#endif
++     {
++	#ifdef USE_GLES
++	Display *xdpy = screen->dpy ();
++	eglSwapBuffers (eglGetDisplay (xdpy), surface);
++	eglWaitGL ();
++	XFlush (xdpy);
++	#else
+ 	/*
+ 	 * controlSwapVideoSync is much faster than waitForVideoSync because
+ 	 * it won't block the CPU. The waiting is offloaded to the GPU.
+@@ -1220,6 +1648,7 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 	 */
+ 	GL::controlSwapVideoSync (optionGetSyncToVblank ());
+ 	glXSwapBuffers (screen->dpy (), cScreen->output ());
++	#endif
+     }
+     else
+     {
+@@ -1229,6 +1658,31 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 
+ 	waitForVideoSync ();
+ 
++	#ifdef USE_GLES
++	Display *xdpy = screen->dpy ();
++
++	if (GL::postSubBuffer)
++	{
++	    while (nBox--)
++	    {
++		y = screen->height () - pBox->y2;
++
++		(*GL::postSubBuffer) (eglGetDisplay (xdpy), surface,
++				      pBox->x1, y,
++				      pBox->x2 - pBox->x1,
++				      pBox->y2 - pBox->y1);
++		pBox++;
++	    }
++	}
++	else
++	{
++	    eglSwapBuffers (eglGetDisplay (xdpy), surface);
++	}
++
++	eglWaitGL ();
++	XFlush (xdpy);
++
++	#else
+ 	if (GL::copySubBuffer)
+ 	{
+ 	    while (nBox--)
+@@ -1275,14 +1729,21 @@ PrivateGLScreen::paintOutputs (CompOutpu
+ 	    glDisable (GL_SCISSOR_TEST);
+ 	    glFlush ();
+ 	}
++	#endif
+     }
++
++    lastMask = mask;
+ }
+ 
+ bool
+ PrivateGLScreen::hasVSync ()
+ {
++   #ifdef USE_GLES
++   return false;
++   #else
+     return GL::waitVideoSync && optionGetSyncToVblank () && 
+            GL::unthrottledFrames < 5;
++   #endif
+ }
+ 
+ bool
+@@ -1327,6 +1788,12 @@ GLScreen::unregisterBindPixmap (GLTextur
+     }
+ }
+ 
++GLFramebufferObject *
++GLScreen::fbo ()
++{
++    return priv->scratchFbo;
++}
++
+ GLTexture *
+ GLScreen::defaultIcon ()
+ {
+@@ -1359,13 +1826,10 @@ GLScreen::defaultIcon ()
+ void
+ GLScreen::resetRasterPos ()
+ {
++    #ifndef USE_GLES
+     glRasterPos2f (0, 0);
++    #endif
+     priv->rasterPos.setX (0);
+     priv->rasterPos.setY (0);
+ }
+ 
+-const float *
+-GLScreen::projectionMatrix ()
+-{
+-    return priv->projection;
+-}
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/program.cpp
+@@ -0,0 +1,262 @@
++/*
++ * Copyright © 2011 Linaro Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Linaro Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Linaro Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Travis Watkins <[e-mail]>
++ */
++
++#include <iostream>
++#include <fstream>
++#include <opengl/opengl.h>
++
++class PrivateProgram
++{
++    public:
++	GLuint program;
++	bool valid;
++};
++
++
++void printShaderInfoLog (GLuint shader)
++{
++    GLint   length = 0;
++    GLint   chars  = 0;
++    GLchar *infoLog;
++
++    (*GL::getShaderiv) (shader, GL_INFO_LOG_LENGTH, &length);
++
++    if (length > 0)
++    {
++	infoLog = new GLchar[length];
++	(*GL::getShaderInfoLog) (shader, length, &chars, infoLog);
++	std::cout << infoLog << std::endl;
++	delete[] infoLog;
++    }
++}
++
++void printProgramInfoLog(GLuint program)
++{
++    GLint   length = 0;
++    GLint   chars  = 0;
++    GLchar *infoLog;
++
++    (*GL::getProgramiv) (program, GL_INFO_LOG_LENGTH, &length);
++
++    if (length > 0)
++    {
++	infoLog = new GLchar[length];
++	(*GL::getProgramInfoLog) (program, length, &chars, infoLog);
++	std::cout << infoLog << std::endl;
++	delete[] infoLog;
++    }
++}
++
++static bool compileShader (GLuint *shader, GLenum type, CompString &source)
++{
++    const GLchar *data;
++    GLint         status;
++
++    data = (GLchar *)source.c_str ();
++
++    *shader = (*GL::createShader) (type);
++    (*GL::shaderSource) (*shader, 1, &data, NULL);
++    (*GL::compileShader) (*shader);
++
++    (*GL::getShaderiv) (*shader, GL_COMPILE_STATUS, &status);
++    return (status == GL_TRUE);
++}
++
++GLProgram::GLProgram (CompString &vertexShader, CompString &fragmentShader) :
++    priv (new PrivateProgram ())
++{
++    GLuint vertex, fragment;
++    GLint status;
++
++    priv->valid = false;
++    priv->program = (*GL::createProgram) ();
++
++    if (!compileShader (&vertex, GL_VERTEX_SHADER, vertexShader))
++    {
++	printShaderInfoLog (vertex);
++	std::cout << vertexShader << std::endl << std::endl;
++	return;
++    }
++
++    if (!compileShader (&fragment, GL_FRAGMENT_SHADER, fragmentShader))
++    {
++	printShaderInfoLog (fragment);
++	std::cout << fragmentShader << std::endl << std::endl;
++	return;
++    }
++
++    (*GL::attachShader) (priv->program, vertex);
++    (*GL::attachShader) (priv->program, fragment);
++
++    (*GL::linkProgram) (priv->program);
++    (*GL::validateProgram) (priv->program);
++
++    (*GL::getProgramiv) (priv->program, GL_LINK_STATUS, &status);
++    if (status == GL_FALSE)
++    {
++	printProgramInfoLog (priv->program);
++	return;
++    }
++
++    (*GL::deleteShader) (vertex);
++    (*GL::deleteShader) (fragment);
++
++    priv->valid = true;
++}
++
++GLProgram::~GLProgram ()
++{
++    (*GL::deleteProgram) (priv->program);
++    delete priv;
++}
++
++bool GLProgram::valid ()
++{
++    return priv->valid;
++}
++
++void GLProgram::bind ()
++{
++    (*GL::useProgram) (priv->program);
++}
++
++void GLProgram::unbind ()
++{
++    (*GL::useProgram) (0);
++}
++
++bool GLProgram::setUniform (const char *name, GLfloat value)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform1f) (location, value);
++    return true;
++}
++
++bool GLProgram::setUniform (const char *name, GLint value)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform1i) (location, value);
++    return true;
++}
++
++bool GLProgram::setUniform (const char *name, const GLMatrix &value)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniformMatrix4fv) (location, 1, GL_FALSE, value.getMatrix ());
++    return true;
++}
++
++bool GLProgram::setUniform2f (const char *name,
++                              GLfloat x,
++                              GLfloat y)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform2f) (location, x, y);
++    return true;
++}
++
++bool GLProgram::setUniform3f (const char *name,
++                              GLfloat x,
++                              GLfloat y,
++                              GLfloat z)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform3f) (location, x, y, z);
++    return true;
++}
++
++bool GLProgram::setUniform4f (const char *name,
++                              GLfloat x,
++                              GLfloat y,
++                              GLfloat z,
++                              GLfloat w)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform4f) (location, x, y, z, w);
++    return true;
++}
++
++bool GLProgram::setUniform2i (const char *name,
++                              GLint x,
++                              GLint y)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform2i) (location, x, y);
++    return true;
++}
++
++bool GLProgram::setUniform3i (const char *name,
++                              GLint x,
++                              GLint y,
++                              GLint z)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform3i) (location, x, y, z);
++    return true;
++}
++
++bool GLProgram::setUniform4i (const char *name,
++                              GLint x,
++                              GLint y,
++                              GLint z,
++                              GLint w)
++{
++    GLint location = (*GL::getUniformLocation) (priv->program, name);
++    if (location == -1)
++	return false;
++
++    (*GL::uniform4i) (location, x, y, z, w);
++    return true;
++}
++
++GLuint GLProgram::attributeLocation (const char *name)
++{
++    return (*GL::getAttribLocation) (priv->program, name);
++}
++
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/framebufferobject.cpp
+@@ -0,0 +1,191 @@
++/*
++ * Copyright (c) 2011 Collabora, Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Collabora Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Collabora Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * COLLABORA LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL COLLABORA LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Pekka Paalanen <[e-mail]>
++ */
++
++#include <map>
++#include <opengl/framebufferobject.h>
++#include <opengl/texture.h>
++
++struct PrivateGLFramebufferObject
++{
++    PrivateGLFramebufferObject () :
++	fboId (0),
++	glTex (NULL)
++    {
++    }
++
++    void pushFBO ();
++    void popFBO ();
++
++    GLuint fboId;
++    GLuint tmpId;
++    GLTexture *glTex;
++
++    static std::map<GLuint, GLFramebufferObject *> idMap;
++};
++
++std::map<GLuint, GLFramebufferObject *> PrivateGLFramebufferObject::idMap;
++
++void
++PrivateGLFramebufferObject::pushFBO ()
++{
++    GLint id = 0;
++    glGetIntegerv (GL_FRAMEBUFFER_BINDING, &id);
++    tmpId = id;
++    if (tmpId == fboId)
++	return;
++
++    (*GL::bindFramebuffer) (GL_FRAMEBUFFER, fboId);
++}
++
++void
++PrivateGLFramebufferObject::popFBO ()
++{
++    if (tmpId != fboId)
++	(*GL::bindFramebuffer) (GL_FRAMEBUFFER, tmpId);
++}
++
++GLFramebufferObject::GLFramebufferObject () :
++    priv (new PrivateGLFramebufferObject)
++{
++    (*GL::genFramebuffers) (1, &priv->fboId);
++    if (priv->fboId != 0)
++	PrivateGLFramebufferObject::idMap[priv->fboId] = this;
++}
++
++GLFramebufferObject::~GLFramebufferObject ()
++{
++    if (priv->glTex)
++	GLTexture::decRef (priv->glTex);
++
++    PrivateGLFramebufferObject::idMap.erase (priv->fboId);
++    (*GL::deleteFramebuffers) (1, &priv->fboId);
++
++    delete priv;
++}
++
++bool
++GLFramebufferObject::allocate (const CompSize &size, const char *image,
++			       GLenum format, GLenum type)
++{
++    if (!priv->glTex ||
++        size.width () != priv->glTex->width () ||
++        size.height () != priv->glTex->height ())
++    {
++	if (priv->glTex)
++	    GLTexture::decRef (priv->glTex);
++	priv->glTex = NULL;
++
++	GLTexture::List list = GLTexture::imageDataToTexture (image, size,
++							      format, type);
++	if (list.size () != 1 || list[0] == NULL)
++	    return false;
++
++	priv->glTex = list[0];
++	GLTexture::incRef (priv->glTex);
++    }
++
++    priv->pushFBO ();
++    (*GL::framebufferTexture2D) (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
++                                 priv->glTex->target (),
++                                 priv->glTex->name (), 0);
++    priv->popFBO ();
++    return true;
++}
++
++GLFramebufferObject *
++GLFramebufferObject::bind ()
++{
++    GLFramebufferObject *old = NULL;
++    GLint id = 0;
++
++    glGetIntegerv (GL_FRAMEBUFFER_BINDING, &id);
++    if (id != 0)
++    {
++	std::map<GLuint, GLFramebufferObject *>::iterator it;
++	it = PrivateGLFramebufferObject::idMap.find (id);
++
++	if (it != PrivateGLFramebufferObject::idMap.end ())
++	    old = it->second;
++	else
++	    compLogMessage ("opengl", CompLogLevelError,
++		"An FBO without GLFramebufferObject cannot be restored");
++    }
++
++    (*GL::bindFramebuffer) (GL_FRAMEBUFFER, priv->fboId);
++
++    return old;
++}
++
++// static
++void
++GLFramebufferObject::rebind (GLFramebufferObject *fbo)
++{
++    GLuint id = fbo ? fbo->priv->fboId : 0;
++    (*GL::bindFramebuffer) (GL_FRAMEBUFFER, id);
++}
++
++static const char *
++getFboErrorString (GLint status)
++{
++    switch (status)
++    {
++	case        GL_FRAMEBUFFER_COMPLETE:
++	    return "GL_FRAMEBUFFER_COMPLETE";
++	case        GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
++	    return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
++	case        GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
++	    return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
++#ifdef USE_GLES
++	case        GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
++	    return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
++#endif
++	case        GL_FRAMEBUFFER_UNSUPPORTED:
++	    return "GL_FRAMEBUFFER_UNSUPPORTED";
++	default:
++	    return "unexpected status";
++    }
++}
++
++bool
++GLFramebufferObject::checkStatus ()
++{
++    priv->pushFBO ();
++    GLint status = (*GL::checkFramebufferStatus) (GL_FRAMEBUFFER);
++    priv->popFBO ();
++
++    if (status == GL_FRAMEBUFFER_COMPLETE)
++	return true;
++
++    compLogMessage ("opengl", CompLogLevelError,
++                    "FBO is incomplete: %s (0x%04x)",
++                    getFboErrorString (status), status);
++    return false;
++}
++
++GLTexture *
++GLFramebufferObject::tex ()
++{
++	return priv->glTex;
++}
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/privatevertexbuffer.h
+@@ -0,0 +1,138 @@
++/*
++ * Copyright © 2011 Linaro Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Linaro Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Linaro Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Travis Watkins <[e-mail]>
++ *          Frederic Plourde <[e-mail]>
++ */
++
++#ifndef _VERTEXBUFFER_PRIVATE_H
++#define _VERTEXBUFFER_PRIVATE_H
++
++#ifdef USE_GLES
++#include <GLES2/gl2.h>
++#else
++#include <GL/gl.h>
++#endif
++
++#include <opengl/program.h>
++#include <typeinfo>
++
++class GLVertexBuffer;
++
++class AbstractUniform
++{
++   public:
++       void virtual set(GLProgram* program) = 0;
++};
++
++template < typename T, int C >
++class Uniform: public AbstractUniform
++{
++    public:
++	Uniform(const char *_name, ... );
++	void set(GLProgram* program);
++
++    public:
++	T a[C];
++	std::string name;
++};
++
++template < typename T, int C >
++Uniform< T, C >::Uniform(const char *_name, ... )
++{
++    va_list arg_list;
++    va_start( arg_list, _name );
++    name = _name;
++    for( int i = 0; i < C; i++ )
++	a[i] = va_arg( arg_list, T );
++    va_end( arg_list );
++}
++
++template < typename T, int C >
++void Uniform< T, C >::set(GLProgram* prog)
++{
++    const char* n = name.c_str();
++
++    // This will only get called from privateVertexBuffer::render
++    // so we know we've got a valid, bound program here
++    if (typeid(a[0]) == typeid(double))
++    {
++	switch (C)
++	{
++	    case 1: prog->setUniform   (n, (GLfloat) a[0]); break;
++	    case 2: prog->setUniform2f (n, a[0], a[1]); break;
++	    case 3: prog->setUniform3f (n, a[0], a[1], a[2]); break;
++	    case 4: prog->setUniform4f (n, a[0], a[1], a[2], a[3]); break;
++	}
++    } else if (typeid(a[0]) == typeid(int))
++    {
++	switch (C)
++	{
++	    case 1: prog->setUniform   (n, (GLint) a[0]); break;
++	    case 2: prog->setUniform2i (n, a[0], a[1]); break;
++	    case 3: prog->setUniform3i (n, a[0], a[1], a[2]); break;
++	    case 4: prog->setUniform4i (n, a[0], a[1], a[2], a[3]); break;
++	}
++    } else
++    {
++	compLogMessage ("opengl", CompLogLevelError, "Unknown uniform type!");
++    }
++}
++
++class GLVertexBuffer;
++
++class PrivateVertexBuffer
++{
++    public:
++	PrivateVertexBuffer ();
++	~PrivateVertexBuffer ();
++
++	int render (const GLMatrix            *projection,
++	            const GLMatrix            *modelview,
++	            const GLWindowPaintAttrib *attrib);
++	int legacyRender (const GLMatrix            &projection,
++	                  const GLMatrix            &modelview,
++	                  const GLWindowPaintAttrib &attrib);
++
++    public:
++	static GLVertexBuffer *streamingBuffer;
++
++	std::vector<GLfloat> vertexData;
++	std::vector<GLfloat> normalData;
++	std::vector<GLfloat> colorData;
++	std::vector<std::vector<GLfloat> > textureData;
++
++	GLProgram *program;
++	GLenum primitiveType;
++	GLenum usage;
++
++	GLuint vertexBuffer;
++	GLuint normalBuffer;
++	GLuint colorBuffer;
++	GLuint textureBuffers[4];
++	std::vector<AbstractUniform*> uniforms;
++
++	GLVertexBuffer::AutoProgram *autoProgram;
++};
++
++#endif //_VERTEXBUFFER_PRIVATE_H
++
+--- compiz-0.9.7.6.orig/plugins/opengl/src/window.cpp
++++ compiz-0.9.7.6/plugins/opengl/src/window.cpp
+@@ -46,6 +46,28 @@ GLWindow::~GLWindow ()
+     delete priv;
+ }
+ 
++
++/**
++ * Callback object to create GLPrograms automatically when using GLVertexBuffer.
++ */
++class GLWindowAutoProgram : public GLVertexBuffer::AutoProgram
++{
++public:
++    GLWindowAutoProgram (PrivateGLWindow *pWindow) : pWindow(pWindow) {}
++
++    GLProgram *getProgram (GLShaderParameters &params)
++    {
++	GLScreen *gScreen = pWindow->gScreen;
++
++	const GLShaderData *shaderData = gScreen->getShaderData (params);
++	pWindow->shaders.push_back (shaderData);
++	return gScreen->getProgram (pWindow->shaders);
++    }
++
++    PrivateGLWindow *pWindow;
++
++};
++
+ PrivateGLWindow::PrivateGLWindow (CompWindow *w,
+ 				  GLWindow   *gw) :
+     window (w),
+@@ -57,7 +79,8 @@ PrivateGLWindow::PrivateGLWindow (CompWi
+     updateReg (true),
+     clip (),
+     bindFailed (false),
+-    geometry (),
++    vertexBuffer (new GLVertexBuffer ()),
++    autoProgram(new GLWindowAutoProgram(this)),
+     icons ()
+ {
+     paint.xScale	= 1.0f;
+@@ -67,10 +90,13 @@ PrivateGLWindow::PrivateGLWindow (CompWi
+ 
+     WindowInterface::setHandler (w);
+     CompositeWindowInterface::setHandler (cWindow);
++    vertexBuffer->setAutoProgram(autoProgram);
+ }
+ 
+ PrivateGLWindow::~PrivateGLWindow ()
+ {
++    delete vertexBuffer;
++    delete autoProgram;
+ }
+ 
+ void
+@@ -105,6 +131,21 @@ GLWindow::bind ()
+ 	compLogMessage ("opengl", CompLogLevelInfo,
+ 			"Couldn't bind redirected window 0x%x to "
+ 			"texture\n", (int) priv->window->id ());
++
++	if (priv->cWindow->size ().width () > GL::maxTextureSize ||
++	    priv->cWindow->size ().height ()  > GL::maxTextureSize)
++	{
++	    compLogMessage ("opengl", CompLogLevelWarn,
++			    "Bug in window 0x%x (identifying as %s)", (int) priv->window->id (), priv->window->resName ().size () ? priv->window->resName ().c_str () : "(none available)");
++	    compLogMessage ("opengl", CompLogLevelWarn,
++			    "This window tried to create an absurdly large window %i x %i\n", priv->cWindow->size ().width (), priv->cWindow->size ().height ());
++	    compLogMessage ("opengl", CompLogLevelWarn,
++			    "Unforunately, that's not supported on your hardware, because you have a maximum texture size of %i", GL::maxTextureSize);
++	    compLogMessage ("opengl", CompLogLevelWarn, "you should probably file a bug against that application");
++	    compLogMessage ("opengl", CompLogLevelWarn, "for now, we're going to hide tht window so that it doesn't break your desktop\n");
++
++	    XReparentWindow (screen->dpy (), priv->window->id (), GLScreen::get (screen)->priv->saveWindow, 0, 0);
++	}
+     }
+ 
+     priv->setWindowMatrix ();
+@@ -132,11 +173,11 @@ GLWindowInterface::glPaint (const GLWind
+     WRAPABLE_DEF (glPaint, attrib, transform, region, mask)
+ 
+ bool
+-GLWindowInterface::glDraw (const GLMatrix     &transform,
+-			   GLFragment::Attrib &fragment,
+-			   const CompRegion   &region,
+-			   unsigned int       mask)
+-    WRAPABLE_DEF (glDraw, transform, fragment, region, mask)
++GLWindowInterface::glDraw (const GLMatrix            &transform,
++			   const GLWindowPaintAttrib &attrib,
++			   const CompRegion          &region,
++			   unsigned int              mask)
++    WRAPABLE_DEF (glDraw, transform, attrib, region, mask)
+ 
+ void
+ GLWindowInterface::glAddGeometry (const GLTexture::MatrixList &matrix,
+@@ -148,14 +189,11 @@ GLWindowInterface::glAddGeometry (const
+ 		  maxGridWidth, maxGridHeight)
+ 
+ void
+-GLWindowInterface::glDrawTexture (GLTexture          *texture,
+-				  GLFragment::Attrib &fragment,
+-				  unsigned int       mask)
+-    WRAPABLE_DEF (glDrawTexture, texture, fragment, mask)
+-
+-void
+-GLWindowInterface::glDrawGeometry ()
+-    WRAPABLE_DEF (glDrawGeometry)
++GLWindowInterface::glDrawTexture (GLTexture                 *texture,
++                                  const GLMatrix            &transform,
++				  const GLWindowPaintAttrib &attrib,
++				  unsigned int              mask)
++    WRAPABLE_DEF (glDrawTexture, texture, transform, attrib, mask)
+ 
+ const CompRegion &
+ GLWindow::clip () const
+@@ -223,76 +261,10 @@ GLWindow::updatePaintAttribs ()
+     priv->paint.saturation = cw->saturation ();
+ }
+ 
+-GLWindow::Geometry &
+-GLWindow::geometry ()
+-{
+-    return priv->geometry;
+-}
+-
+-GLWindow::Geometry::Geometry () :
+-    vertices (NULL),
+-    vertexSize (0),
+-    vertexStride (0),
+-    indices (NULL),
+-    indexSize (0),
+-    vCount (0),
+-    texUnits (0),
+-    texCoordSize (0),
+-    indexCount (0)
+-{
+-}
+-
+-GLWindow::Geometry::~Geometry ()
+-{
+-    if (vertices)
+-	free (vertices);
+-
+-    if (indices)
+-	free (indices);
+-}
+-
+-void
+-GLWindow::Geometry::reset ()
+-{
+-    vCount = indexCount = 0;
+-}
+-
+-bool
+-GLWindow::Geometry::moreVertices (int newSize)
+-{
+-    if (newSize > vertexSize)
+-    {
+-	GLfloat *nVertices;
+-
+-	nVertices = (GLfloat *)
+-	    realloc (vertices, sizeof (GLfloat) * newSize);
+-	if (!nVertices)
+-	    return false;
+-
+-	vertices = nVertices;
+-	vertexSize = newSize;
+-    }
+-
+-    return true;
+-}
+-
+-bool
+-GLWindow::Geometry::moreIndices (int newSize)
++GLVertexBuffer *
++GLWindow::vertexBuffer ()
+ {
+-    if (newSize > indexSize)
+-    {
+-	GLushort *nIndices;
+-
+-	nIndices = (GLushort *)
+-	    realloc (indices, sizeof (GLushort) * newSize);
+-	if (!nIndices)
+-	    return false;
+-
+-	indices = nIndices;
+-	indexSize = newSize;
+-    }
+-
+-    return true;
++    return priv->vertexBuffer;
+ }
+ 
+ const GLTexture::List &
+@@ -335,6 +307,19 @@ GLWindow::getIcon (int width, int height
+ }
+ 
+ void
++GLWindow::addShaders (std::string name,
++                      std::string vertex_shader,
++                      std::string fragment_shader)
++{
++    GLShaderData *data = new GLShaderData;
++    data->name = name;
++    data->vertexShader = vertex_shader;
++    data->fragmentShader = fragment_shader;
++
++    priv->shaders.push_back(data);
++}
++
++void
+ PrivateGLWindow::updateFrameRegion (CompRegion &region)
+ {
+     window->updateFrameRegion (region);
+--- compiz-0.9.7.6.orig/plugins/opengl/src/privatetexture.h
++++ compiz-0.9.7.6/plugins/opengl/src/privatetexture.h
+@@ -1,6 +1,7 @@
+ /*
+  * Copyright © 2008 Dennis Kasprzyk
+  * Copyright © 2007 Novell, Inc.
++ * Copyright © 2011 Linaro Ltd.
+  *
+  * Permission to use, copy, modify, distribute, and sell this software
+  * and its documentation for any purpose is hereby granted without
+@@ -23,13 +24,21 @@
+  *
+  * Authors: Dennis Kasprzyk <[e-mail]>
+  *          David Reveman <[e-mail]>
++ *          Travis Watkins <[e-mail]>
+  */
+ 
+ #ifndef _PRIVATETEXTURE_H
+ #define _PRIVATETEXTURE_H
+ 
++#ifdef USE_GLES
++#define SUPPORT_X11
++#include <GLES2/gl2.h>
++#include <EGL/egl.h>
++#include <EGL/eglext.h>
++#else
+ #include <GL/gl.h>
+ #include <GL/glx.h>
++#endif
+ #include <opengl/texture.h>
+ #include <X11/extensions/Xdamage.h>
+ 
+@@ -62,6 +71,28 @@ class PrivateTexture {
+ 	int               refCount;
+ };
+ 
++#ifdef USE_GLES
++class EglTexture : public GLTexture {
++    public:
++	EglTexture ();
++	~EglTexture ();
++
++	void enable (Filter filter);
++
++	static List bindPixmapToTexture (Pixmap pixmap,
++					 int width,
++					 int height,
++					 int depth);
++
++    public:
++	bool        damaged;
++	Damage      damage;
++	bool        updateMipMap;
++};
++
++extern std::map<Damage, EglTexture*> boundPixmapTex;
++#else
++
+ class TfpTexture : public GLTexture {
+     public:
+ 	TfpTexture ();
+@@ -82,5 +113,6 @@ class TfpTexture : public GLTexture {
+ };
+ 
+ extern std::map<Damage, TfpTexture*> boundPixmapTex;
++#endif
+ 
+ #endif
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/programcache.cpp
+@@ -0,0 +1,175 @@
++/*
++ * Copyright © 2011 Linaro Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Linaro Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Linaro Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Travis Watkins <[e-mail]>
++ */
++
++#include <opengl/programcache.h>
++#include "privates.h"
++
++typedef std::list<std::string> access_history_t;
++typedef std::pair<GLProgram*, access_history_t::iterator> value;
++
++static GLProgram *
++compileProgram (std::string name, std::list<const GLShaderData*> shaders)
++{
++    std::list<const GLShaderData*>::const_iterator it;
++    std::string vertex_shader;
++    std::string fragment_shader;
++    std::string vertex_functions = "";
++    std::string vertex_function_calls = "";
++    std::string fragment_functions = "";
++    std::string fragment_function_calls = "";
++    int vpos, vcallpos, fpos, fcallpos;
++
++    for (it = shaders.begin (); it != shaders.end (); it++)
++    {
++	//find the special shaders to put the rest in
++	if ((*it)->vertexShader.find ("@VERTEX_FUNCTIONS@") != std::string::npos)
++	{
++	    vertex_shader = (*it)->vertexShader;
++	}
++	else
++	{
++	    if ((*it)->vertexShader.length ())
++	    {
++		vertex_functions += (*it)->vertexShader;
++		vertex_function_calls += (*it)->name + "_vertex();\n";
++	    }
++	}
++
++	if ((*it)->fragmentShader.find ("@FRAGMENT_FUNCTIONS@") != std::string::npos)
++	{
++	    fragment_shader = (*it)->fragmentShader;
++	}
++	else
++	{
++	    if ((*it)->fragmentShader.length ())
++	    {
++		fragment_functions += (*it)->fragmentShader;
++		fragment_function_calls += (*it)->name + "_fragment();\n";
++	    }
++	}
++    }
++
++    // put shader functions and function calls into the main shader
++    vpos = vertex_shader.find ("@VERTEX_FUNCTIONS@");
++    vertex_shader.replace (vpos, 18, vertex_functions);
++
++    vcallpos = vertex_shader.find ("@VERTEX_FUNCTION_CALLS@");
++    vertex_shader.replace (vcallpos, 23, vertex_function_calls);
++
++    fpos = fragment_shader.find ("@FRAGMENT_FUNCTIONS@");
++    fragment_shader.replace (fpos, 20, fragment_functions);
++
++    fcallpos = fragment_shader.find ("@FRAGMENT_FUNCTION_CALLS@");
++    fragment_shader.replace (fcallpos, 25, fragment_function_calls);
++
++    return new GLProgram (vertex_shader, fragment_shader);
++}
++
++class PrivateProgramCache
++{
++    public:
++	PrivateProgramCache (size_t);
++
++	const size_t                 capacity;
++	access_history_t             access_history;
++	std::map<std::string, value> cache;
++
++	void insert (std::string, GLProgram *);
++	void evict ();
++};
++
++GLProgramCache::GLProgramCache (size_t capacity) :
++    priv (new PrivateProgramCache (capacity))
++{
++    assert (priv->capacity != 0);
++}
++
++GLProgramCache::~GLProgramCache ()
++{
++    delete priv;
++}
++ 
++GLProgram* GLProgramCache::operator () (std::list<const GLShaderData*> shaders)
++{
++    std::list<const GLShaderData*>::const_iterator name_it;
++    std::string name;
++
++    for (name_it = shaders.begin(); name_it != shaders.end(); name_it++)
++    {
++	if (name.length () == 0)
++	    name += (*name_it)->name;
++	else
++	    name += ":" + (*name_it)->name;
++    }
++
++    std::map<std::string, value>::iterator it = priv->cache.find (name);
++ 
++    if (it == priv->cache.end ())
++    {
++	GLProgram *program = compileProgram (name, shaders);
++	priv->insert (name, program);
++	return program;
++    }
++    else
++    {
++	priv->access_history.splice (priv->access_history.end (),
++	                             priv->access_history,
++	                             (*it).second.second);
++	(*it).second.second = priv->access_history.rbegin ().base ();
++
++	return (*it).second.first;
++    }
++}
++
++PrivateProgramCache::PrivateProgramCache (size_t c) :
++    capacity (c)
++{
++}
++
++void PrivateProgramCache::insert (std::string name, GLProgram *program)
++{
++    assert (cache.find (name) == cache.end ());
++
++    if (cache.size () == capacity)
++	evict ();
++
++    // update most recently used GLProgram
++    access_history_t::iterator it = access_history.insert (access_history.end (), name);
++
++    cache.insert (std::make_pair (name, std::make_pair (program, it)));
++}
++
++void PrivateProgramCache::evict ()
++{
++    assert (!access_history.empty ());
++
++    // find least recently used GLProgram
++    std::map<std::string, value>::iterator it = cache.find (access_history.front ());
++    assert (it != cache.end ());
++ 
++    cache.erase (it);
++    access_history.pop_front ();
++}
++
+--- compiz-0.9.7.6.orig/plugins/opengl/src/privates.h
++++ compiz-0.9.7.6/plugins/opengl/src/privates.h
+@@ -32,8 +32,12 @@
+ #include <opengl/opengl.h>
+ #include <core/atoms.h>
+ 
+-#include "privatefragment.h"
++#ifdef USE_GLES
++#include <opengl/framebufferobject.h>
++#endif
++
+ #include "privatetexture.h"
++#include "privatevertexbuffer.h"
+ #include "opengl_options.h"
+ 
+ extern CompOutput *targetOutput;
+@@ -75,8 +79,9 @@ class PrivateGLScreen :
+ 	void controlSwapVideoSync ();
+ 	void waitForVideoSync ();
+ 
+-	void paintBackground (const CompRegion &region,
+-			      bool             transformed);
++	void paintBackground (const GLMatrix   &transform,
++	                      const CompRegion &region,
++                              bool             transformed);
+ 
+ 	void paintOutputRegion (const GLMatrix   &transform,
+ 			        const CompRegion &region,
+@@ -94,7 +99,9 @@ class PrivateGLScreen :
+ 
+ 	GLenum textureFilter;
+ 
++	#ifndef USE_GLES
+ 	GLFBConfig      glxPixmapFBConfigs[MAX_DEPTH + 1];
++	#endif
+ 
+ 	GLTexture::List backgroundTextures;
+ 	bool            backgroundLoaded;
+@@ -103,28 +110,41 @@ class PrivateGLScreen :
+ 
+ 	CompPoint rasterPos;
+ 
+-	GLFragment::Storage fragmentStorage;
+-
+-	GLfloat projection[16];
++	GLMatrix *projection;
+ 
+ 	bool clearBuffers;
+ 	bool lighting;
+ 
+-	GL::GLXGetProcAddressProc getProcAddress;
+-
++	#ifdef USE_GLES
++	EGLContext ctx;
++	EGLSurface surface;
++	#else
+ 	GLXContext ctx;
+ 
++	GL::GLXGetProcAddressProc getProcAddress;
++	#endif
++
++	GLFramebufferObject *scratchFbo;
+ 	CompRegion outputRegion;
+ 
+ 	bool pendingCommands;
+ 
+ 	XRectangle lastViewport;
++	bool refreshSubBuffer;
++	unsigned int lastMask;
+ 
+ 	std::vector<GLTexture::BindPixmapProc> bindPixmap;
+ 	bool hasCompositing;
+ 
+ 	GLIcon defaultIcon;
+ 
++	Window saveWindow; // hack for broken applications, see:
++			   // https://bugs.launchpad.net/ubuntu/+source/compiz/+bug/807487
++
++	GLProgramCache *programCache;
++	GLShaderCache   shaderCache;
++	GLVertexBuffer::AutoProgram *autoProgram;
++
+ 	Pixmap rootPixmapCopy;
+ 	CompSize rootPixmapSize;
+ };
+@@ -169,10 +189,15 @@ class PrivateGLWindow :
+ 
+ 	unsigned int lastMask;
+ 
+-	GLWindow::Geometry geometry;
++	GLVertexBuffer *vertexBuffer;
++
++	// map of shaders, plugin name is key, pair of vertex and fragment
++	// shader source code is value
++	std::list<const GLShaderData*> shaders;
++	GLVertexBuffer::AutoProgram *autoProgram;
+ 
+ 	std::list<GLIcon> icons;
+ };
+ 
+-
+ #endif
++
+--- compiz-0.9.7.6.orig/plugins/opengl/src/matrix.cpp
++++ compiz-0.9.7.6/plugins/opengl/src/matrix.cpp
+@@ -163,6 +163,60 @@ operator* (const GLMatrix& lhs,
+ #undef B
+ #undef P
+ 
++/*
++** Invert 4x4 matrix.
++** Contributed by David Moore (See Mesa bug #6748)
++*/
++bool GLMatrix::invert ()
++{
++    float inv[16], det;
++    int i;
++
++    inv[0] =   m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
++             + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
++    inv[4] =  -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
++             - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
++    inv[8] =   m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
++             + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
++    inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
++             - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
++    inv[1] =  -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
++             - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
++    inv[5] =   m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
++             + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
++    inv[9] =  -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
++             - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
++    inv[13] =  m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
++             + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
++    inv[2] =   m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
++             + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
++    inv[6] =  -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
++             - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
++    inv[10] =  m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
++             + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
++    inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
++             - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
++    inv[3] =  -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
++             - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
++    inv[7] =   m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
++             + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
++    inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
++             - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
++    inv[15] =  m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
++             + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
++
++    det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
++    if (det == 0)
++        return false;
++
++    det = 1.0f / det;
++
++    for (i = 0; i < 16; i++)
++        m[i] = inv[i] * det;
++
++    return true;
++}
++
+ /**
+  * Generate a 4x4 transformation matrix from glRotate parameters, and
+  * post-multiply the input matrix by it.
+--- compiz-0.9.7.6.orig/plugins/opengl/src/texture.cpp
++++ compiz-0.9.7.6/plugins/opengl/src/texture.cpp
+@@ -35,7 +35,11 @@
+ #include <privatetexture.h>
+ #include "privates.h"
+ 
++#ifdef USE_GLES
++std::map<Damage, EglTexture*> boundPixmapTex;
++#else
+ std::map<Damage, TfpTexture*> boundPixmapTex;
++#endif
+ 
+ static GLTexture::Matrix _identity_matrix = {
+     1.0f, 0.0f,
+@@ -150,7 +154,7 @@ GLTexture::matrix () const
+ bool
+ GLTexture::mipmap () const
+ {
+-    return priv->mipmap & priv->mipmapSupport;
++    return priv->mipmap && priv->mipmapSupport;
+ }
+ 
+ GLenum
+@@ -163,7 +167,9 @@ void
+ GLTexture::enable (GLTexture::Filter filter)
+ {
+     GLScreen *gs = GLScreen::get (screen);
++#ifndef USE_GLES
+     glEnable (priv->target);
++#endif
+     glBindTexture (priv->target, priv->name);
+ 
+     if (filter == Fast)
+@@ -184,7 +190,7 @@ GLTexture::enable (GLTexture::Filter fil
+     {
+ 	if (gs->textureFilter () == GL_LINEAR_MIPMAP_LINEAR)
+ 	{
+-	    if (GL::textureNonPowerOfTwo && GL::fbo && priv->mipmap)
++	    if (mipmap ())
+ 	    {
+ 		glTexParameteri (priv->target,
+ 				 GL_TEXTURE_MIN_FILTER,
+@@ -226,7 +232,7 @@ GLTexture::enable (GLTexture::Filter fil
+     {
+ 	if (priv->initial)
+ 	{
+-	    (*GL::generateMipmap) (priv->target);
++	    GL::generateMipmap (priv->target);
+ 	    priv->initial = false;
+ 	}
+     }
+@@ -236,7 +242,9 @@ void
+ GLTexture::disable ()
+ {
+     glBindTexture (priv->target, 0);
++#ifndef USE_GLES
+     glDisable (priv->target);
++#endif
+ }
+ 
+ void
+@@ -295,20 +303,26 @@ PrivateTexture::loadImageData (const cha
+     rv[0] = t;
+ 
+     GLTexture::Matrix matrix = _identity_matrix;
+-    CompOption        *opt;
+     GLint             internalFormat;
+     GLenum            target;
+     bool              mipmap;
++    bool              pot = POWER_OF_TWO (width) && POWER_OF_TWO (height);
+ 
++    #ifdef USE_GLES
++    target = GL_TEXTURE_2D;
++    matrix.xx = 1.0f / width;
++    matrix.yy = 1.0f / height;
++    matrix.y0 = 0.0f;
++    mipmap = GL::textureNonPowerOfTwoMipmap || pot;
++    #else
+ 
+-    if (GL::textureNonPowerOfTwo ||
+-	(POWER_OF_TWO (width) && POWER_OF_TWO (height)))
++    if (GL::textureNonPowerOfTwo || pot)
+     {
+ 	target = GL_TEXTURE_2D;
+ 	matrix.xx = 1.0f / width;
+ 	matrix.yy = 1.0f / height;
+ 	matrix.y0 = 0.0f;
+-	mipmap = true;
++	mipmap = GL::fbo && (GL::textureNonPowerOfTwoMipmap || pot);
+     }
+     else
+     {
+@@ -318,17 +332,26 @@ PrivateTexture::loadImageData (const cha
+ 	matrix.y0 = 0.0f;
+ 	mipmap = false;
+     }
++    #endif
+ 
+     t->setData (target, matrix, mipmap);
+     t->setGeometry (0, 0, width, height);
+ 
+     glBindTexture (target, t->name ());
+ 
++    #ifdef USE_GLES
++//    internalFormat = GL_BGRA;
++    internalFormat = GL_BGRA;
++    #else
++    internalFormat = GL_RGBA;
++    #endif
++
++    #ifndef USE_GLES
++    CompOption *opt;
+     opt = GLScreen::get (screen)->getOption ("texture_compression");
+     if (opt->value ().b () && GL::textureCompression)
+ 	internalFormat = GL_COMPRESSED_RGBA_ARB;
+-    else
+-	internalFormat =  GL_RGBA;
++    #endif
+ 
+     glTexImage2D (target, 0, internalFormat, width, height, 0,
+ 		  format, type, image);
+@@ -413,6 +436,106 @@ GLTexture::bindPixmapToTexture (Pixmap p
+     return GLTexture::List ();
+ }
+ 
++#ifdef USE_GLES
++EglTexture::EglTexture () :
++    damaged (true),
++    damage (None),
++    updateMipMap (true)
++{
++}
++
++EglTexture::~EglTexture ()
++{
++    GLuint temp = name ();
++    glBindTexture (target (), name ());
++
++    glDeleteTextures (1, &temp);
++
++    glBindTexture (target (), 0);
++
++    boundPixmapTex.erase (damage);
++    XDamageDestroy (screen->dpy (), damage);
++}
++
++GLTexture::List
++EglTexture::bindPixmapToTexture (Pixmap pixmap,
++				 int    width,
++				 int    height,
++				 int    depth)
++{
++    if ((int) width > GL::maxTextureSize || (int) height > GL::maxTextureSize ||
++        !GL::textureFromPixmap)
++	return GLTexture::List ();
++
++    GLTexture::List   rv (1);
++    EglTexture        *tex = NULL;
++    EGLImageKHR       eglImage = NULL;
++    GLTexture::Matrix matrix = _identity_matrix;
++
++    const EGLint img_attribs[] = {
++	EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
++	EGL_NONE
++    };
++
++    eglImage = GL::createImage (eglGetDisplay (screen->dpy ()),
++                                EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
++                                (EGLClientBuffer)pixmap, img_attribs);
++
++    if (eglImage == EGL_NO_IMAGE_KHR)
++    {
++	compLogMessage ("core", CompLogLevelWarn,
++			"eglCreateImageKHR failed");
++
++	return GLTexture::List ();
++    }
++
++    matrix.xx = 1.0f / width;
++    matrix.yy = 1.0f / height;
++    matrix.y0 = 0.0f;
++
++    tex = new EglTexture ();
++    tex->setData (GL_TEXTURE_2D, matrix,
++	GL::textureNonPowerOfTwoMipmap ||
++	(POWER_OF_TWO (width) && POWER_OF_TWO (height)));
++    tex->setGeometry (0, 0, width, height);
++
++    rv[0] = tex;
++
++    glBindTexture (GL_TEXTURE_2D, tex->name ());
++
++    GL::eglImageTargetTexture (GL_TEXTURE_2D, (GLeglImageOES)eglImage);
++    GL::destroyImage (eglGetDisplay (screen->dpy ()), eglImage);
++
++    tex->setFilter (GL_NEAREST);
++    tex->setWrap (GL_CLAMP_TO_EDGE);
++
++    glBindTexture (GL_TEXTURE_2D, 0);
++
++    tex->damage = XDamageCreate (screen->dpy (), pixmap,
++			         XDamageReportRawRectangles);
++    boundPixmapTex[tex->damage] = tex;
++
++    return rv;
++}
++
++void
++EglTexture::enable (GLTexture::Filter filter)
++{
++    glBindTexture (target (), name ());
++    GLTexture::enable (filter);
++    
++    if (damaged)
++	updateMipMap = true;
++
++    if (this->filter () == GL_LINEAR_MIPMAP_LINEAR && updateMipMap)
++    {
++	GL::generateMipmap (target ());
++	updateMipMap = false;
++    }
++    damaged = false;
++}
++#else
++
+ TfpTexture::TfpTexture () :
+     pixmap (0),
+     damaged (true),
+@@ -611,3 +734,5 @@ TfpTexture::enable (GLTexture::Filter fi
+     }
+     damaged = false;
+ }
++#endif
++
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/vertexbuffer.cpp
+@@ -0,0 +1,550 @@
++/*
++ * Copyright © 2011 Linaro Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Linaro Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Linaro Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Travis Watkins <[e-mail]>
++ *          Frederic Plourde <[e-mail]>
++ *          Alexandros Frantzis <[e-mail]>
++ */
++
++#include <vector>
++#include <iostream>
++
++#ifdef USE_GLES
++#include <GLES2/gl2.h>
++#else
++#include <GL/gl.h>
++#include <GL/glext.h>
++#endif
++
++#include <opengl/vertexbuffer.h>
++
++#include "privates.h"
++
++GLVertexBuffer *PrivateVertexBuffer::streamingBuffer = NULL;
++
++GLVertexBuffer::GLVertexBuffer () :
++    priv (new PrivateVertexBuffer ())
++{
++    priv->usage = GL_STATIC_DRAW;
++}
++
++GLVertexBuffer::GLVertexBuffer (GLenum usage) :
++    priv (new PrivateVertexBuffer ())
++{
++    priv->usage = usage;
++}
++
++GLVertexBuffer::~GLVertexBuffer ()
++{
++    delete priv;
++}
++
++GLVertexBuffer *GLVertexBuffer::streamingBuffer ()
++{
++    if (PrivateVertexBuffer::streamingBuffer == NULL)
++	PrivateVertexBuffer::streamingBuffer = new GLVertexBuffer
++	                                                      (GL_STREAM_DRAW);
++    return PrivateVertexBuffer::streamingBuffer;
++}
++
++void GLVertexBuffer::begin (GLenum primitiveType)
++{
++    priv->primitiveType = primitiveType;
++
++    priv->vertexData.clear ();
++    priv->normalData.clear ();
++    priv->colorData.clear ();
++    priv->textureData.clear ();
++    priv->uniforms.clear ();
++}
++
++void GLVertexBuffer::begin ()
++{
++    begin (GL_TRIANGLES);
++}
++
++int GLVertexBuffer::end ()
++{
++    if (!GL::vbo)
++	return 0;
++
++    if (!priv->vertexData.size ())
++	return -1;
++
++    GL::bindBuffer (GL_ARRAY_BUFFER, priv->vertexBuffer);
++    GL::bufferData (GL_ARRAY_BUFFER,
++                    sizeof(GLfloat) * priv->vertexData.size (),
++                    &priv->vertexData[0], priv->usage);
++
++    if (priv->normalData.size ())
++    {
++	GL::bindBuffer (GL_ARRAY_BUFFER, priv->normalBuffer);
++	GL::bufferData (GL_ARRAY_BUFFER,
++	                sizeof(GLfloat) * priv->normalData.size (),
++	                &priv->normalData[0], priv->usage);
++    }
++
++    if (priv->colorData.size ())
++    {
++	GL::bindBuffer (GL_ARRAY_BUFFER, priv->colorBuffer);
++	GL::bufferData (GL_ARRAY_BUFFER,
++	                sizeof(GLfloat) * priv->colorData.size (),
++	                &priv->colorData[0], priv->usage);
++    }
++
++    if (priv->textureData.size ())
++    {
++	for (unsigned int i = 0; i < priv->textureData.size (); i++)
++	{
++	    GL::bindBuffer (GL_ARRAY_BUFFER, priv->textureBuffers[i]);
++	    GL::bufferData (GL_ARRAY_BUFFER,
++	                    sizeof(GLfloat) * priv->textureData[i].size (),
++	                    &priv->textureData[i][0], priv->usage);
++	}
++    }
++
++    GL::bindBuffer (GL_ARRAY_BUFFER, 0);
++
++    return 0;
++}
++
++void GLVertexBuffer::addVertices (GLuint nVertices, GLfloat *vertices)
++{
++    priv->vertexData.reserve (priv->vertexData.size () + (nVertices * 3));
++
++    for (GLuint i = 0; i < nVertices * 3; i++)
++    {
++	priv->vertexData.push_back (vertices[i]);
++    }
++}
++
++void GLVertexBuffer::addNormals (GLuint nNormals, GLfloat *normals)
++{
++    priv->normalData.reserve (priv->normalData.size () + (nNormals * 3));
++
++    for (GLuint i = 0; i < nNormals * 3; i++)
++    {
++	priv->normalData.push_back (normals[i]);
++    }
++}
++
++void GLVertexBuffer::addColors (GLuint nColors, GLushort *colors)
++{
++    priv->colorData.reserve (priv->colorData.size () + (nColors * 4));
++
++    for (GLuint i = 0; i < nColors * 4; i++)
++    {
++	priv->colorData.push_back (colors[i] / 65535.0f);
++    }
++}
++
++void GLVertexBuffer::addTexCoords (GLuint texture,
++                                   GLuint nTexcoords,
++                                   GLfloat *texcoords)
++{
++    //four textures max (zero indexed)
++    if (texture > 3)
++	return;
++
++    while (texture >= priv->textureData.size ())
++    {
++	std::vector<GLfloat> temp;
++	priv->textureData.push_back (temp);
++    }
++
++    priv->textureData[texture].reserve (priv->textureData[texture].size () +
++                                        (nTexcoords * 2));
++
++    for (GLuint i = 0; i < nTexcoords * 2; i++)
++    {
++	priv->textureData[texture].push_back (texcoords[i]);
++    }
++}
++
++void GLVertexBuffer::addUniform (const char *name, GLfloat value)
++{
++    // we're casting to double here to make our template va_arg happy
++    Uniform<double, 1>* uniform = new Uniform<double, 1>(name, (double)value);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform (const char *name, GLint value)
++{
++    Uniform<GLint, 1>* uniform = new Uniform<GLint, 1>(name, value);
++    priv->uniforms.push_back (uniform);
++}
++
++bool GLVertexBuffer::addUniform (const char *name, const GLMatrix &value)
++{
++    //#warning Add 'addUniform' support to GLMatrix type !
++    return true;
++}
++
++void GLVertexBuffer::addUniform2f (const char *name,
++                                   GLfloat x,
++                                   GLfloat y)
++{
++    // we're casting to double here to make our template va_arg happy
++    Uniform<double, 2>* uniform = new Uniform<double, 2>(name,
++							 (double)x,
++							 (double)y);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform3f (const char *name,
++                                   GLfloat x,
++                                   GLfloat y,
++                                   GLfloat z)
++{
++     // we're casting to double here to make our template va_arg happy
++    Uniform<double, 3>* uniform = new Uniform<double, 3>(name,
++							 (double)x,
++							 (double)y,
++							 (double)z);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform4f (const char *name,
++                                   GLfloat x,
++                                   GLfloat y,
++                                   GLfloat z,
++                                   GLfloat w)
++{
++    // we're casting to double here to make our template va_arg happy
++    Uniform<double, 4>* uniform = new Uniform<double, 4>(name,
++							 (double)x,
++							 (double)y,
++							 (double)z,
++							 (double)w);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform2i (const char *name,
++                                   GLint x,
++                                   GLint y)
++{
++    Uniform<GLint, 2>* uniform = new Uniform<GLint, 2>(name, x, y);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform3i (const char *name,
++                                   GLint x,
++                                   GLint y,
++                                   GLint z)
++{
++    Uniform<GLint, 3>* uniform = new Uniform<GLint, 3>(name, x, y, z);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::addUniform4i (const char *name,
++                                   GLint x,
++                                   GLint y,
++                                   GLint z,
++                                   GLint w)
++{
++    Uniform<GLint, 4>* uniform = new Uniform<GLint, 4>(name, x, y, z, w);
++    priv->uniforms.push_back (uniform);
++}
++
++void GLVertexBuffer::setProgram (GLProgram *program)
++{
++    priv->program = program;
++}
++
++void GLVertexBuffer::setAutoProgram (AutoProgram *autoProgram)
++{
++    priv->autoProgram = autoProgram;
++}
++
++int GLVertexBuffer::render ()
++{
++    if (GL::vbo && GL::shaders)
++	return priv->render (NULL, NULL, NULL);
++    else
++	return -1;
++}
++
++int GLVertexBuffer::render (const GLMatrix &modelview)
++{
++    const GLWindowPaintAttrib attrib = { OPAQUE, BRIGHT, COLOR, 0, 0, 0, 0 };
++
++    return render (modelview, attrib);
++}
++
++int GLVertexBuffer::render (const GLMatrix            &modelview,
++                            const GLWindowPaintAttrib &attrib)
++{
++    GLScreen *gScreen = GLScreen::get (screen);
++    GLMatrix *projection = gScreen->projectionMatrix ();
++
++    return render (*projection, modelview, attrib);
++}
++
++int GLVertexBuffer::render (const GLMatrix            &projection,
++                            const GLMatrix            &modelview,
++                            const GLWindowPaintAttrib &attrib)
++{
++    if (!priv->vertexData.size ())
++	return -1;
++
++    if (GL::vbo && GL::shaders)
++	return priv->render (&projection, &modelview, &attrib);
++    else
++	return priv->legacyRender (projection, modelview, attrib);
++}
++
++PrivateVertexBuffer::PrivateVertexBuffer () :
++    program (NULL)
++{
++    if (!GL::vbo)
++	return;
++
++    GL::genBuffers (1, &vertexBuffer);
++    GL::genBuffers (1, &normalBuffer);
++    GL::genBuffers (1, &colorBuffer);
++    GL::genBuffers (4, &textureBuffers[0]);
++}
++
++PrivateVertexBuffer::~PrivateVertexBuffer ()
++{
++    if (!GL::vbo)
++	return;
++
++    GL::deleteBuffers (1, &vertexBuffer);
++    GL::deleteBuffers (1, &normalBuffer);
++    GL::deleteBuffers (1, &colorBuffer);
++    GL::deleteBuffers (4, &textureBuffers[0]);
++}
++
++int PrivateVertexBuffer::render (const GLMatrix            *projection,
++                                 const GLMatrix            *modelview,
++                                 const GLWindowPaintAttrib *attrib)
++{
++    GLfloat attribs[3] = {1, 1, 1};
++    GLint positionIndex = -1;
++    GLint normalIndex = -1;
++    GLint colorIndex = -1;
++    GLint texCoordIndex[4] = {-1, -1, -1, -1};
++    GLProgram *tmpProgram = program;
++
++    // If we don't have an explicitly set program, try to get one
++    // using the AutoProgram callback object.
++    if (tmpProgram == NULL && autoProgram) {
++	// Convert attrib to shader parameters
++	GLShaderParameters params;
++
++	params.opacity = attrib->opacity != OPAQUE;
++	params.brightness = attrib->brightness != BRIGHT;
++	params.saturation = attrib->saturation != COLOR;
++	params.color = colorData.size () == 4 ? GLShaderVariableUniform :
++	               colorData.size () >  4 ? GLShaderVariableVarying :
++	                                        GLShaderVariableNone;
++	params.normal = normalData.size () <= 4 ? GLShaderVariableUniform :
++	                                          GLShaderVariableVarying;
++	params.numTextures = textureData.size ();
++
++	// Get a program matching the parameters
++	tmpProgram = autoProgram->getProgram(params);
++    }
++
++    if (tmpProgram == NULL)
++    {
++	std::cerr << "no program defined!" << std::endl;
++	return -1;
++    }
++
++    tmpProgram->bind ();
++    if (!tmpProgram->valid ())
++    {
++	return -1;
++    }
++
++    if (projection)
++	tmpProgram->setUniform ("projection", *projection);
++
++    if (modelview)
++	tmpProgram->setUniform ("modelview", *modelview);
++
++    positionIndex = tmpProgram->attributeLocation ("position");
++    (*GL::enableVertexAttribArray) (positionIndex);
++    (*GL::bindBuffer) (GL_ARRAY_BUFFER, vertexBuffer);
++    (*GL::vertexAttribPointer) (positionIndex, 3, GL_FLOAT, GL_FALSE, 0, 0);
++
++    //use default normal
++    if (normalData.size () == 0)
++    {
++	tmpProgram->setUniform3f ("singleNormal", 0.0f, 0.0f, -1.0f);
++    }
++    // special case a single normal and apply it to the entire operation
++    else if (normalData.size () == 3)
++    {
++	tmpProgram->setUniform3f ("singleNormal",
++	                       normalData[0], normalData[1], normalData[2]);
++    }
++    else if (normalData.size () > 3)
++    {
++	normalIndex = tmpProgram->attributeLocation ("normal");
++	(*GL::enableVertexAttribArray) (normalIndex);
++	(*GL::bindBuffer) (GL_ARRAY_BUFFER, normalBuffer);
++	(*GL::vertexAttribPointer) (normalIndex, 3, GL_FLOAT, GL_FALSE, 0, 0);
++    }
++
++    // special case a single color and apply it to the entire operation
++    if (colorData.size () == 4)
++    {
++	tmpProgram->setUniform4f ("singleColor", colorData[0],
++	                       colorData[1], colorData[2], colorData[3]);
++    }
++    else if (colorData.size () > 4)
++    {
++	colorIndex = tmpProgram->attributeLocation ("color");
++	(*GL::enableVertexAttribArray) (colorIndex);
++	(*GL::bindBuffer) (GL_ARRAY_BUFFER, colorBuffer);
++	(*GL::vertexAttribPointer) (colorIndex, 4, GL_FLOAT, GL_FALSE, 0, 0);
++    }
++
++    for (int i = textureData.size () - 1; i >= 0; i--)
++    {
++	char name[10];
++
++	snprintf (name, 10, "texCoord%d", i);
++	texCoordIndex[i] = tmpProgram->attributeLocation (name);
++
++	(*GL::enableVertexAttribArray) (texCoordIndex[i]);
++	(*GL::bindBuffer) (GL_ARRAY_BUFFER, textureBuffers[i]);
++	(*GL::vertexAttribPointer) (texCoordIndex[i], 2, GL_FLOAT, GL_FALSE, 0, 0);
++
++	snprintf (name, 9, "texture%d", i);
++	tmpProgram->setUniform (name, i);
++    }
++
++    // set per-plugin uniforms
++    for (unsigned int i = 0; i < uniforms.size (); i++)
++    {
++	uniforms[i]->set (program);
++    }
++
++    //convert paint attribs to 0-1 range
++    if (attrib)
++    {
++	attribs[0] = attrib->opacity  / 65535.0f;
++	attribs[1] = attrib->brightness / 65535.0f;
++	attribs[2] = attrib->saturation / 65535.0f;
++	tmpProgram->setUniform3f ("paintAttrib", attribs[0], attribs[1], attribs[2]);
++    }
++
++    glDrawArrays (primitiveType, 0, vertexData.size () / 3);
++
++    for (int i = 0; i < 4; ++i)
++    {
++	if (texCoordIndex[i] != -1)
++	    (*GL::disableVertexAttribArray) (texCoordIndex[i]);
++    }
++
++    if (colorIndex != -1)
++	(*GL::disableVertexAttribArray) (colorIndex);
++
++    if (normalIndex != -1)
++	(*GL::disableVertexAttribArray) (normalIndex);
++
++    (*GL::disableVertexAttribArray) (positionIndex);
++
++    GL::bindBuffer (GL_ARRAY_BUFFER, 0);
++    tmpProgram->unbind ();
++
++    return 0;
++}
++
++int PrivateVertexBuffer::legacyRender (const GLMatrix            &projection,
++                                       const GLMatrix            &modelview,
++                                       const GLWindowPaintAttrib &attrib)
++{
++    #ifndef USE_GLES
++    glMatrixMode (GL_PROJECTION);
++    glPushMatrix ();
++    glLoadMatrixf (projection.getMatrix ());
++
++    glMatrixMode (GL_MODELVIEW);
++    glPushMatrix ();
++    glLoadMatrixf (modelview.getMatrix ());
++
++    glEnableClientState (GL_VERTEX_ARRAY);
++    glVertexPointer (3, GL_FLOAT, 0, &vertexData[0]);
++
++    //use default normal
++    if (normalData.size () == 0)
++    {
++	glNormal3f (0.0f, 0.0f, -1.0f);
++    }
++    // special case a single normal and apply it to the entire operation
++    else if (normalData.size () == 3)
++    {
++	glNormal3fv (&normalData[0]);
++    }
++    else if (normalData.size () > 3)
++    {
++	glEnableClientState (GL_NORMAL_ARRAY);
++	glNormalPointer (GL_FLOAT, 0, &normalData[0]);
++    }
++
++    // special case a single color and apply it to the entire operation
++    if (colorData.size () == 4)
++    {
++	glColor4fv (&colorData[0]);
++    }
++    else if (colorData.size () > 4)
++    {
++	glEnableClientState (GL_COLOR_ARRAY);
++	glColorPointer (4, GL_FLOAT, 0, &colorData[0]);
++    }
++
++    for (int i = textureData.size () - 1; i >= 0; i--)
++    {
++	GL::clientActiveTexture (GL_TEXTURE0_ARB + i);
++	glEnableClientState (GL_TEXTURE_COORD_ARRAY);
++	glTexCoordPointer (2, GL_FLOAT, 0, &textureData[i][0]);
++    }
++
++    glDrawArrays (primitiveType, 0, vertexData.size () / 3);
++
++    glDisableClientState (GL_VERTEX_ARRAY);
++    glDisableClientState (GL_NORMAL_ARRAY);
++    glDisableClientState (GL_COLOR_ARRAY);
++
++    for (int i = textureData.size (); i > 0; i--)
++    {
++	GL::clientActiveTexture (GL_TEXTURE0_ARB + i);
++	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
++    }
++
++    GL::clientActiveTexture (GL_TEXTURE0_ARB);
++
++    glMatrixMode (GL_PROJECTION);
++    glPopMatrix ();
++
++    glMatrixMode (GL_MODELVIEW);
++    glPopMatrix ();
++    #endif
++
++    return 0;
++}
++
+--- compiz-0.9.7.6.orig/plugins/opengl/src/paint.cpp
++++ compiz-0.9.7.6/plugins/opengl/src/paint.cpp
+@@ -1,5 +1,6 @@
+ /*
+  * Copyright © 2005 Novell, Inc.
++ * Copyright © 2011 Linaro, Ltd.
+  *
+  * Permission to use, copy, modify, distribute, and sell this software
+  * and its documentation for any purpose is hereby granted without
+@@ -20,7 +21,8 @@
+  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  *
+- * Author: David Reveman <[e-mail]>
++ * Authors: David Reveman <[e-mail]>
++ *          Travis Watkins <[e-mail]>
+  */
+ 
+ #include "privates.h"
+@@ -35,6 +37,8 @@
+ 
+ #include <opengl/opengl.h>
+ 
++#include "privates.h"
++
+ #define DEG2RAD (M_PI / 180.0f)
+ 
+ GLScreenPaintAttrib defaultScreenPaintAttrib = {
+@@ -64,14 +68,16 @@ GLScreen::glApplyTransform (const GLScre
+ }
+ 
+ void
+-PrivateGLScreen::paintBackground (const CompRegion &region,
+-				  bool             transformed)
++PrivateGLScreen::paintBackground (const GLMatrix   &transform,
++                                  const CompRegion &region,
++                                  bool             transformed)
+ {
++    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
++    GLfloat         vertexData[18];
++    GLushort        colorData[4];
++
+     BoxPtr    pBox = const_cast <Region> (region.handle ())->rects;
+     int	      n, nBox = const_cast <Region> (region.handle ())->numRects;
+-    GLfloat   *d;
+-
+-    boost::scoped_array <GLfloat> data;
+ 
+     if (!nBox)
+ 	return;
+@@ -97,86 +103,111 @@ PrivateGLScreen::paintBackground (const
+ 
+     if (backgroundTextures.empty ())
+     {
+-	data.reset (new GLfloat [nBox * 8]);
+-
+-	d = data.get ();
++	streamingBuffer->begin (GL_TRIANGLES);
+ 	n = nBox;
+ 
+ 	while (n--)
+ 	{
+-	    *d++ = pBox->x1;
+-	    *d++ = pBox->y2;
+-
+-	    *d++ = pBox->x2;
+-	    *d++ = pBox->y2;
++	    vertexData[0]  = pBox->x1;
++	    vertexData[1]  = pBox->y1;
++	    vertexData[2]  = 0.0f;
++	    vertexData[3]  = pBox->x1;
++	    vertexData[4]  = pBox->y2;
++	    vertexData[5]  = 0.0f;
++	    vertexData[6]  = pBox->x2;
++	    vertexData[7]  = pBox->y1;
++	    vertexData[8]  = 0.0f;
++	    vertexData[9]  = pBox->x1;
++	    vertexData[10] = pBox->y2;
++	    vertexData[11] = 0.0f;
++	    vertexData[12] = pBox->x2;
++	    vertexData[13] = pBox->y2;
++	    vertexData[14] = 0.0f;
++
++	    vertexData[15] = pBox->x2;
++	    vertexData[16] = pBox->y1;
++	    vertexData[17] = 0.0f;
+ 
+-	    *d++ = pBox->x2;
+-	    *d++ = pBox->y1;
+-
+-	    *d++ = pBox->x1;
+-	    *d++ = pBox->y1;
++	    streamingBuffer->addVertices (6, vertexData);
+ 
+ 	    pBox++;
+ 	}
+ 
+-	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
+-
+-	glVertexPointer (2, GL_FLOAT, sizeof (GLfloat) * 2, &data[0]);
++	colorData[0] = colorData[1] = colorData[2] = 0;
++	colorData[3] = std::numeric_limits <unsigned short>::max ();
++	streamingBuffer->addColors (1, colorData);
+ 
+-	glColor4us (0, 0, 0, std::numeric_limits<unsigned short>::max ());
+-	glDrawArrays (GL_QUADS, 0, nBox * 4);
+-	glColor4usv (defaultColor);
+-
+-	glEnableClientState (GL_TEXTURE_COORD_ARRAY);
++	streamingBuffer->end ();
++	streamingBuffer->render (transform);
+     }
+     else
+     {
+-	data.reset (new GLfloat [nBox * 16]);
+-
+-	d = data.get ();
+ 	n = nBox;
+ 
+ 	for (unsigned int i = 0; i < backgroundTextures.size (); i++)
+ 	{
++	    GLfloat textureData[12];
+ 	    GLTexture *bg = backgroundTextures[i];
+ 	    CompRegion r = region & *bg;
+ 
+ 	    pBox = const_cast <Region> (r.handle ())->rects;
+ 	    nBox = const_cast <Region> (r.handle ())->numRects;
+-	    d = data.get ();
+ 	    n = nBox;
+ 
++	    streamingBuffer->begin (GL_TRIANGLES);
++
+ 	    while (n--)
+ 	    {
+-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
+-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y2);
+-
+-		*d++ = pBox->x1;
+-		*d++ = pBox->y2;
+-
+-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
+-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y2);
+-
+-		*d++ = pBox->x2;
+-		*d++ = pBox->y2;
+-
+-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
+-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y1);
++		GLfloat tx1 = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
++		GLfloat tx2 = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
++		GLfloat ty1 = COMP_TEX_COORD_Y (bg->matrix (), pBox->y1);
++		GLfloat ty2 = COMP_TEX_COORD_Y (bg->matrix (), pBox->y2);
++
++		vertexData[0]  = pBox->x1;
++		vertexData[1]  = pBox->y1;
++		vertexData[2]  = 0.0f;
++		vertexData[3]  = pBox->x1;
++		vertexData[4]  = pBox->y2;
++		vertexData[5]  = 0.0f;
++		vertexData[6]  = pBox->x2;
++		vertexData[7]  = pBox->y1;
++		vertexData[8]  = 0.0f;
++		vertexData[9]  = pBox->x1;
++		vertexData[10] = pBox->y2;
++		vertexData[11] = 0.0f;
++		vertexData[12] = pBox->x2;
++		vertexData[13] = pBox->y2;
++		vertexData[14] = 0.0f;
++
++		vertexData[15] = pBox->x2;
++		vertexData[16] = pBox->y1;
++		vertexData[17] = 0.0f;
++
++		textureData[0]  = tx1;
++		textureData[1]  = ty1;
++
++		textureData[2]  = tx1;
++		textureData[3]  = ty2;
++
++		textureData[4]  = tx2;
++		textureData[5]  = ty1;
++
++		textureData[6]  = tx1;
++		textureData[7]  = ty2;
+ 
+-		*d++ = pBox->x2;
+-		*d++ = pBox->y1;
++		textureData[8]  = tx2;
++		textureData[9]  = ty2;
+ 
+-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
+-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y1);
++		textureData[10] = tx2;
++		textureData[11] = ty1;
+ 
+-		*d++ = pBox->x1;
+-		*d++ = pBox->y1;
++		streamingBuffer->addVertices (6, vertexData);
++		streamingBuffer->addTexCoords (0, 6, textureData);
+ 
+ 		pBox++;
+ 	    }
+ 
+-	    glTexCoordPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, &data[0]);
+-	    glVertexPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, &data[2]);
++	    streamingBuffer->end ();
+ 
+ 	    if (bg->name ())
+ 	    {
+@@ -185,7 +216,7 @@ PrivateGLScreen::paintBackground (const
+ 		else
+ 		    bg->enable (GLTexture::Fast);
+ 
+-		glDrawArrays (GL_QUADS, 0, nBox * 4);
++		streamingBuffer->render (transform);
+ 
+ 		bg->disable ();
+ 	    }
+@@ -329,7 +360,9 @@ PrivateGLScreen::paintOutputRegion (cons
+ 	CompositeWindow::get (fullscreenWindow)->unredirect ();
+ 
+     if (!(mask & PAINT_SCREEN_NO_BACKGROUND_MASK))
+-	paintBackground (tmpRegion, (mask & PAINT_SCREEN_TRANSFORMED_MASK));
++	paintBackground (transform,
++	                 tmpRegion,
++	                 (mask & PAINT_SCREEN_TRANSFORMED_MASK));
+ 
+     /* paint all windows from bottom to top */
+     foreach (w, pl)
+@@ -377,6 +410,7 @@ GLScreen::glEnableOutputClipping (const
+ {
+     WRAPABLE_HND_FUNCTN (glEnableOutputClipping, transform, region, output)
+ 
++    #ifndef USE_GLES
+     GLdouble h = screen->height ();
+ 
+     GLdouble p1[2] = { static_cast<GLdouble> (region.handle ()->extents.x1),
+@@ -409,6 +443,7 @@ GLScreen::glEnableOutputClipping (const
+     glEnable (GL_CLIP_PLANE3);
+ 
+     glPopMatrix ();
++    #endif
+ }
+ 
+ void
+@@ -416,10 +451,12 @@ GLScreen::glDisableOutputClipping ()
+ {
+     WRAPABLE_HND_FUNCTN (glDisableOutputClipping)
+ 
++    #ifndef USE_GLES
+     glDisable (GL_CLIP_PLANE0);
+     glDisable (GL_CLIP_PLANE1);
+     glDisable (GL_CLIP_PLANE2);
+     glDisable (GL_CLIP_PLANE3);
++    #endif
+ }
+ 
+ #define CLIP_PLANE_MASK (PAINT_SCREEN_TRANSFORMED_MASK | \
+@@ -449,26 +486,14 @@ GLScreen::glPaintTransformedOutput (cons
+ 	glEnableOutputClipping (sTransform, region, output);
+ 
+ 	sTransform.toScreenSpace (output, -sAttrib.zTranslate);
+-
+-	glPushMatrix ();
+-	glLoadMatrixf (sTransform.getMatrix ());
+-
+ 	priv->paintOutputRegion (sTransform, region, output, mask);
+ 
+-	glPopMatrix ();
+-
+ 	glDisableOutputClipping ();
+     }
+     else
+     {
+ 	sTransform.toScreenSpace (output, -sAttrib.zTranslate);
+-
+-	glPushMatrix ();
+-	glLoadMatrixf (sTransform.getMatrix ());
+-
+ 	priv->paintOutputRegion (sTransform, region, output, mask);
+-
+-	glPopMatrix ();
+     }
+ }
+ 
+@@ -503,13 +528,8 @@ GLScreen::glPaintOutput (const GLScreenP
+ 
+ 	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
+ 
+-	glPushMatrix ();
+-	glLoadMatrixf (sTransform.getMatrix ());
+-
+ 	priv->paintOutputRegion (sTransform, region, output, mask);
+ 
+-	glPopMatrix ();
+-
+ 	return true;
+     }
+     else if (mask & PAINT_SCREEN_FULL_MASK)
+@@ -525,182 +545,260 @@ GLScreen::glPaintOutput (const GLScreenP
+     }
+ }
+ 
+-#define ADD_RECT(data, m, n, x1, y1, x2, y2)	   \
+-    for (it = 0; it < n; it++)			   \
+-    {						   \
+-        const GLTexture::Matrix &mat = m[it];	   \
+-	*(data)++ = COMP_TEX_COORD_X (mat, x1);    \
+-	*(data)++ = COMP_TEX_COORD_Y (mat, y1);    \
+-    }						   \
+-    *(data)++ = (x1);				   \
+-    *(data)++ = (y1);				   \
+-    *(data)++ = 0.0;				   \
+-    for (it = 0; it < n; it++)			   \
+-    {						   \
+-        const GLTexture::Matrix &mat = m[it];	   \
+-	*(data)++ = COMP_TEX_COORD_X (mat, x1);    \
+-	*(data)++ = COMP_TEX_COORD_Y (mat, y2);    \
+-    }						   \
+-    *(data)++ = (x1);				   \
+-    *(data)++ = (y2);				   \
+-    *(data)++ = 0.0;				   \
+-    for (it = 0; it < n; it++)			   \
+-    {						   \
+-        const GLTexture::Matrix &mat = m[it];	   \
+-	*(data)++ = COMP_TEX_COORD_X (mat, x2);    \
+-	*(data)++ = COMP_TEX_COORD_Y (mat, y2);    \
+-    }						   \
+-    *(data)++ = (x2);				   \
+-    *(data)++ = (y2);				   \
+-    *(data)++ = 0.0;				   \
+-    for (it = 0; it < n; it++)			   \
+-    {						   \
+-        const GLTexture::Matrix &mat = m[it];	   \
+-	*(data)++ = COMP_TEX_COORD_X (mat, x2);    \
+-	*(data)++ = COMP_TEX_COORD_Y (mat, y1);    \
+-    }						   \
+-    *(data)++ = (x2);				   \
+-    *(data)++ = (y1);				   \
+-    *(data)++ = 0.0
+-
+-#define ADD_QUAD(data, m, n, x1, y1, x2, y2)		\
+-    for (it = 0; it < n; it++)				\
+-    {							\
+-        const GLTexture::Matrix &mat = m[it];		\
+-	*(data)++ = COMP_TEX_COORD_XY (mat, x1, y1);	\
+-	*(data)++ = COMP_TEX_COORD_YX (mat, x1, y1);	\
+-    }							\
+-    *(data)++ = (x1);					\
+-    *(data)++ = (y1);					\
+-    *(data)++ = 0.0;					\
+-    for (it = 0; it < n; it++)				\
+-    {							\
+-        const GLTexture::Matrix &mat = m[it];		\
+-	*(data)++ = COMP_TEX_COORD_XY (mat, x1, y2);	\
+-	*(data)++ = COMP_TEX_COORD_YX (mat, x1, y2);	\
+-    }							\
+-    *(data)++ = (x1);					\
+-    *(data)++ = (y2);					\
+-    *(data)++ = 0.0;					\
+-    for (it = 0; it < n; it++)				\
+-    {							\
+-        const GLTexture::Matrix &mat = m[it];	        \
+-	*(data)++ = COMP_TEX_COORD_XY (mat, x2, y2);	\
+-	*(data)++ = COMP_TEX_COORD_YX (mat, x2, y2);	\
+-    }							\
+-    *(data)++ = (x2);					\
+-    *(data)++ = (y2);					\
+-    *(data)++ = 0.0;					\
+-    for (it = 0; it < n; it++)				\
+-    {							\
+-        const GLTexture::Matrix &mat = m[it];	        \
+-	*(data)++ = COMP_TEX_COORD_XY (mat, x2, y1);	\
+-	*(data)++ = COMP_TEX_COORD_YX (mat, x2, y1);	\
+-    }							\
+-    *(data)++ = (x2);					\
+-    *(data)++ = (y1);					\
+-    *(data)++ = 0.0;
+-
+ void
+-GLWindow::glDrawGeometry ()
++GLScreen::glPaintCompositedOutput (const CompRegion    &region,
++				   GLFramebufferObject *fbo,
++				   unsigned int         mask)
+ {
+-    WRAPABLE_HND_FUNCTN (glDrawGeometry)
+-
+-    int     texUnit = priv->geometry.texUnits;
+-    int     currentTexUnit = 0;
+-    int     stride = priv->geometry.vertexStride;
+-    GLfloat *vertices = priv->geometry.vertices + (stride - 3);
++    WRAPABLE_HND_FUNCTN (glPaintCompositedOutput, region, fbo, mask)
+ 
+-    stride *= sizeof (GLfloat);
++    GLMatrix sTransform;
++    std::vector<GLfloat> vertexData;
++    std::vector<GLfloat> textureData;
++    const GLTexture::Matrix & texmatrix = fbo->tex ()->matrix ();
++    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
++
++    streamingBuffer->begin (GL_TRIANGLES);
++
++    if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
++    {
++	GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, 0.0f);
++	GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, screen->width ());
++	GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, 0.0f);
++	GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, screen->height ());
++
++	vertexData = {
++	    0.0f,                    0.0f,                     0.0f,
++	    0.0f,                    (float)screen->height (), 0.0f,
++	    (float)screen->width (), 0.0f,                     0.0f,
++
++	    0.0f,                    (float)screen->height (), 0.0f,
++	    (float)screen->width (), (float)screen->height (), 0.0f,
++	    (float)screen->width (), 0.0f,                     0.0f,
++	};
++
++	textureData = {
++	    tx1, ty1,
++	    tx1, ty2,
++	    tx2, ty1,
++	    tx1, ty2,
++	    tx2, ty2,
++	    tx2, ty1,
++	};
+ 
+-    glVertexPointer (3, GL_FLOAT, stride, vertices);
+-
+-    while (texUnit--)
++	streamingBuffer->addVertices (6, &vertexData[0]);
++	streamingBuffer->addTexCoords (0, 6, &textureData[0]);
++    }
++    else
+     {
+-	if (texUnit != currentTexUnit)
++	BoxPtr pBox = const_cast <Region> (region.handle ())->rects;
++	int nBox = const_cast <Region> (region.handle ())->numRects;
++
++	while (nBox--)
+ 	{
+-	    (*GL::clientActiveTexture) (GL_TEXTURE0_ARB + texUnit);
+-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+-	    currentTexUnit = texUnit;
++	    GLfloat tx1 = COMP_TEX_COORD_X (texmatrix, pBox->x1);
++	    GLfloat tx2 = COMP_TEX_COORD_X (texmatrix, pBox->x2);
++	    GLfloat ty1 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y1);
++	    GLfloat ty2 = 1.0 - COMP_TEX_COORD_Y (texmatrix, pBox->y2);
++
++	    vertexData = {
++		(float)pBox->x1, (float)pBox->y1, 0.0f,
++		(float)pBox->x1, (float)pBox->y2, 0.0f,
++		(float)pBox->x2, (float)pBox->y1, 0.0f,
++
++		(float)pBox->x1, (float)pBox->y2, 0.0f,
++		(float)pBox->x2, (float)pBox->y2, 0.0f,
++		(float)pBox->x2, (float)pBox->y1, 0.0f,
++	    };
++
++	    textureData = {
++		tx1, ty1,
++		tx1, ty2,
++		tx2, ty1,
++		tx1, ty2,
++		tx2, ty2,
++		tx2, ty1,
++	    };
++
++	    streamingBuffer->addVertices (6, &vertexData[0]);
++	    streamingBuffer->addTexCoords (0, 6, &textureData[0]);
++	    pBox++;
+ 	}
+-	vertices -= priv->geometry.texCoordSize;
+-	glTexCoordPointer (priv->geometry.texCoordSize,
+-			   GL_FLOAT, stride, vertices);
+     }
+ 
+-    glDrawArrays (GL_QUADS, 0, priv->geometry.vCount);
+-
+-    /* disable all texture coordinate arrays except 0 */
+-    texUnit = priv->geometry.texUnits;
+-    if (texUnit > 1)
+-    {
+-	while (--texUnit)
+-	{
+-	    (*GL::clientActiveTexture) (GL_TEXTURE0_ARB + texUnit);
+-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
+-	}
++    streamingBuffer->end ();
++    fbo->tex ()-> enable (GLTexture::Fast);
++    sTransform.toScreenSpace (&screen->fullscreenOutput (), -DEFAULT_Z_CAMERA);
++    streamingBuffer->render (sTransform);
++    fbo->tex ()-> disable ();
++}
+ 
+-	(*GL::clientActiveTexture) (GL_TEXTURE0_ARB);
++#define ADD_RECT(vertexBuffer, m, n, x1, y1, x2, y2) \
++    GLfloat vertexData[18] = {                       \
++	(float)x1, (float)y1, 0.0,                   \
++	(float)x1, (float)y2, 0.0,                   \
++	(float)x2, (float)y1, 0.0,                   \
++	(float)x2, (float)y1, 0.0,                   \
++	(float)x1, (float)y2, 0.0,                   \
++	(float)x2, (float)y2, 0.0                    \
++    };                                               \
++    vertexBuffer->addVertices (6, vertexData);       \
++                                                     \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x1);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x1);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x2);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x2);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x1);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_X (mat, x2);        \
++	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }
++
++#define ADD_QUAD(vertexBuffer, m, n, x1, y1, x2, y2) \
++    GLfloat vertexData[18] = {                       \
++	(float)x1, (float)y1, 0.0,                   \
++	(float)x1, (float)y2, 0.0,                   \
++	(float)x2, (float)y1, 0.0,                   \
++	(float)x2, (float)y1, 0.0,                   \
++	(float)x1, (float)y2, 0.0,                   \
++	(float)x2, (float)y2, 0.0                    \
++    };                                               \
++    vertexBuffer->addVertices (6, vertexData);       \
++                                                     \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x1, y1);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x1, y1);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x1, y2);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x1, y2);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x2, y1);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x2, y1);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x2, y1);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x2, y1);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x1, y2);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x1, y2);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
++    }                                                \
++    for (it = 0; it < n; it++)                       \
++    {                                                \
++	GLfloat data[2];                             \
++	const GLTexture::Matrix &mat = m[it];        \
++	data[0] = COMP_TEX_COORD_XY (mat, x2, y2);   \
++	data[1] = COMP_TEX_COORD_YX (mat, x2, y2);   \
++	vertexBuffer->addTexCoords (it, 1, data);    \
+     }
+-}
++
+ 
+ static inline void
+-addSingleQuad (GLfloat      *&d,
+-	       const        GLTexture::MatrixList &matrix,
+-	       unsigned int nMatrix,
+-	       int          x1,
+-	       int          y1,
+-	       int          x2,
+-	       int          y2,
+-	       int          &n,
+-	       bool         rect)
++addSingleQuad (GLVertexBuffer *vertexBuffer,
++               const GLTexture::MatrixList &matrix,
++               unsigned int nMatrix,
++               int          x1,
++               int          y1,
++               int          x2,
++               int          y2,
++               int          &n,
++               bool         rect)
+ {
+     unsigned int it;
+ 
+     if (rect)
+     {
+-	ADD_RECT (d, matrix, nMatrix, x1, y1, x2, y2);
++	ADD_RECT (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2);
+     }
+     else
+     {
+-	ADD_QUAD (d, matrix, nMatrix, x1, y1, x2, y2);
++	ADD_QUAD (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2);
+     }
+     n++;
+ }
+ 
+ static inline void
+-addQuads (GLfloat      *&d,
+-	  const        GLTexture::MatrixList &matrix,
+-	  unsigned int nMatrix,
+-	  int          x1,
+-	  int          y1,
+-	  int          x2,
+-	  int          y2,
+-	  int          &n,
+-	  int          vSize,
+-	  bool         rect,
+-	  GLWindow::Geometry &geometry,
+-	  unsigned int maxGridWidth,
+-	  unsigned int maxGridHeight)
++addQuads (GLVertexBuffer *vertexBuffer,
++          const GLTexture::MatrixList &matrix,
++          unsigned int nMatrix,
++          int          x1,
++          int          y1,
++          int          x2,
++          int          y2,
++          int          &n,
++          bool         rect,
++          unsigned int maxGridWidth,
++          unsigned int maxGridHeight)
+ {
+     int nQuadsX = (maxGridWidth == MAXSHORT) ? 1 :
+ 	1 + (x2 - x1 - 1) / (int) maxGridWidth;  // ceil. division
+     int nQuadsY = (maxGridHeight == MAXSHORT) ? 1 :
+ 	1 + (y2 - y1 - 1) / (int) maxGridHeight;
+-    int newVertexSize = (n + nQuadsX * nQuadsY) * vSize * 4;
+-
+-    // Make sure enough vertices are allocated for nQuadsX * nQuadsY more quads
+-    if (newVertexSize > geometry.vertexSize)
+-    {
+-	if (!geometry.moreVertices (newVertexSize))
+-	    return;
+-
+-	d = geometry.vertices + (n * vSize * 4);
+-    }
+ 
+     if (nQuadsX == 1 && nQuadsY == 1)
+     {
+-	addSingleQuad (d, matrix, nMatrix, x1, y1, x2, y2, n, rect);
++	addSingleQuad (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2, n, rect);
+     }
+     else
+     {
+@@ -716,7 +814,8 @@ addQuads (GLfloat      *&d,
+ 	    {
+ 		nx2 = MIN (nx1 + (int) quadWidth, x2);
+ 
+-		addSingleQuad (d, matrix, nMatrix, nx1, ny1, nx2, ny2, n, rect);
++		addSingleQuad (vertexBuffer, matrix, nMatrix,
++		               nx1, ny1, nx2, ny2, n, rect);
+ 	    }
+ 	}
+     }
+@@ -729,13 +828,11 @@ GLWindow::glAddGeometry (const GLTexture
+ 			 unsigned int                maxGridWidth,
+ 			 unsigned int                maxGridHeight)
+ {
+-    WRAPABLE_HND_FUNCTN (glAddGeometry, matrix, region, clip)
++    WRAPABLE_HND_FUNCTN (glAddGeometry, matrix, region, clip, maxGridWidth, maxGridHeight)
+ 
+     BoxRec full;
+     int    nMatrix = matrix.size ();
+ 
+-    priv->geometry.texUnits = nMatrix;
+-
+     full = clip.handle ()->extents;
+     if (region.handle ()->extents.x1 > full.x1)
+ 	full.x1 = region.handle ()->extents.x1;
+@@ -753,9 +850,7 @@ GLWindow::glAddGeometry (const GLTexture
+ 	BoxPtr  pClip;
+ 	int     nClip;
+ 	BoxRec  cbox;
+-	int     vSize;
+ 	int     n, it, x1, y1, x2, y2;
+-	GLfloat *d;
+ 	bool    rect = true;
+ 
+ 	for (it = 0; it < nMatrix; it++)
+@@ -770,18 +865,6 @@ GLWindow::glAddGeometry (const GLTexture
+ 	pBox = const_cast <Region> (region.handle ())->rects;
+ 	nBox = const_cast <Region> (region.handle ())->numRects;
+ 
+-	vSize = 3 + nMatrix * 2;
+-
+-	n = priv->geometry.vCount / 4;
+-
+-	if ((n + nBox) * vSize * 4 > priv->geometry.vertexSize)
+-	{
+-	    if (!priv->geometry.moreVertices ((n + nBox) * vSize * 4))
+-		return;
+-	}
+-
+-	d = priv->geometry.vertices + (priv->geometry.vCount * vSize);
+-
+ 	while (nBox--)
+ 	{
+ 	    x1 = pBox->x1;
+@@ -806,24 +889,15 @@ GLWindow::glAddGeometry (const GLTexture
+ 
+ 		if (nClip == 1)
+ 		{
+-		    addQuads (d, matrix, nMatrix,
++		    addQuads (priv->vertexBuffer, matrix, nMatrix,
+ 			      x1, y1, x2, y2,
+-			      n, vSize, rect, priv->geometry,
++			      n, rect,
+ 			      maxGridWidth, maxGridHeight);
+ 		}
+ 		else
+ 		{
+ 		    pClip = const_cast <Region> (clip.handle ())->rects;
+ 
+-		    if (((n + nClip) * vSize * 4) > priv->geometry.vertexSize)
+-		    {
+-			if (!priv->geometry.moreVertices ((n + nClip) *
+-							  vSize * 4))
+-			    return;
+-
+-			d = priv->geometry.vertices + (n * vSize * 4);
+-		    }
+-
+ 		    while (nClip--)
+ 		    {
+ 			cbox = *pClip;
+@@ -841,120 +915,32 @@ GLWindow::glAddGeometry (const GLTexture
+ 
+ 			if (cbox.x1 < cbox.x2 && cbox.y1 < cbox.y2)
+ 			{
+-			    addQuads (d, matrix, nMatrix,
++			    addQuads (priv->vertexBuffer, matrix, nMatrix,
+ 				      cbox.x1, cbox.y1, cbox.x2, cbox.y2,
+-				      n, vSize, rect, priv->geometry,
++				      n, rect,
+ 				      maxGridWidth, maxGridHeight);
+ 			}
+ 		    }
+ 		}
+ 	    }
+ 	}
+-
+-	priv->geometry.vCount       = n * 4;
+-	priv->geometry.vertexStride = vSize;
+-	priv->geometry.texCoordSize = 2;
+-    }
+-}
+-
+-static bool
+-enableFragmentProgramAndDrawGeometry (GLScreen	         *gs,
+-				      GLWindow           *w,
+-				      GLTexture          *texture,
+-				      GLFragment::Attrib &attrib,
+-				      GLTexture::Filter  filter,
+-				      unsigned int       mask)
+-{
+-    GLFragment::Attrib fa (attrib);
+-    bool               blending;
+-
+-    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
+-    {
+-	int param, function;
+-
+-	param    = fa.allocParameters (1);
+-	function =
+-	    GLFragment::getSaturateFragmentFunction (texture, param);
+-
+-	fa.addFunction (function);
+-
+-	(*GL::programEnvParameter4f) (GL_FRAGMENT_PROGRAM_ARB, param,
+-				      RED_SATURATION_WEIGHT,
+-				      GREEN_SATURATION_WEIGHT,
+-				      BLUE_SATURATION_WEIGHT,
+-				      attrib.getSaturation () / 65535.0f);
+-    }
+-
+-    if (!fa.enable (&blending))
+-	return false;
+-
+-    texture->enable (filter);
+-
+-    if (mask & PAINT_WINDOW_BLEND_MASK)
+-    {
+-	if (blending)
+-	    glEnable (GL_BLEND);
+-
+-	if (attrib.getOpacity () != OPAQUE || attrib.getBrightness () != BRIGHT)
+-	{
+-	    GLushort color;
+-
+-	    color = (attrib.getOpacity () * attrib.getBrightness ()) >> 16;
+-
+-	    gs->setTexEnvMode (GL_MODULATE);
+-	    glColor4us (color, color, color, attrib.getOpacity ());
+-
+-	    w->glDrawGeometry ();
+-
+-	    glColor4usv (defaultColor);
+-	    gs->setTexEnvMode (GL_REPLACE);
+-	}
+-	else
+-	{
+-	    w->glDrawGeometry ();
+-	}
+-
+-	if (blending)
+-	    glDisable (GL_BLEND);
+-    }
+-    else if (attrib.getBrightness () != BRIGHT)
+-    {
+-	gs->setTexEnvMode (GL_MODULATE);
+-	glColor4us (attrib.getBrightness (), attrib.getBrightness (),
+-		    attrib.getBrightness (), BRIGHT);
+-
+-	w->glDrawGeometry ();
+-
+-	glColor4usv (defaultColor);
+-	gs->setTexEnvMode (GL_REPLACE);
+     }
+-    else
+-    {
+-	w->glDrawGeometry ();
+-    }
+-
+-    texture->disable ();
+-
+-    fa.disable ();
+-
+-    return true;
+ }
+ 
++#ifndef USE_GLES
+ static void
+-enableFragmentOperationsAndDrawGeometry (GLScreen	    *gs,
+-					 GLWindow	    *w,
+-					 GLTexture	    *texture,
+-					 GLFragment::Attrib &attrib,
+-					 GLTexture::Filter  filter,
+-					 unsigned int	    mask)
++enableLegacyOBSAndRender (GLScreen                  *gs,
++                          GLWindow                  *w,
++                          GLTexture                 *texture,
++                          const GLMatrix            &transform,
++                          const GLWindowPaintAttrib &attrib,
++                          GLTexture::Filter         filter,
++                          unsigned int              mask)
+ {
+-    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
++    if (GL::canDoSaturated && attrib.saturation != COLOR)
+     {
+ 	GLfloat constant[4];
+ 
+-	if (mask & PAINT_WINDOW_BLEND_MASK)
+-	    glEnable (GL_BLEND);
+-
+ 	texture->enable (filter);
+ 
+ 	glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
+@@ -985,7 +971,7 @@ enableFragmentOperationsAndDrawGeometry
+ 	glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
+ 	glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
+ 
+-	if (GL::canDoSlightlySaturated && attrib.getSaturation () > 0)
++	if (GL::canDoSlightlySaturated && attrib.saturation > 0)
+ 	{
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
+@@ -1016,20 +1002,20 @@ enableFragmentOperationsAndDrawGeometry
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
+ 
+-	    constant[3] = attrib.getSaturation () / 65535.0f;
++	    constant[3] = attrib.saturation / 65535.0f;
+ 
+ 	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
+ 
+-	    if (attrib.getOpacity () < OPAQUE ||
+-		attrib.getBrightness () != BRIGHT)
++	    if (attrib.opacity < OPAQUE ||
++		attrib.brightness != BRIGHT)
+ 	    {
+ 		GL::activeTexture (GL_TEXTURE3_ARB);
+ 
+ 		texture->enable (filter);
+ 
+-		constant[3] = attrib.getOpacity () / 65535.0f;
++		constant[3] = attrib.opacity / 65535.0f;
+ 		constant[0] = constant[1] = constant[2] = constant[3] *
+-		    attrib.getBrightness () / 65535.0f;
++		    attrib.brightness / 65535.0f;
+ 
+ 		glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
+ 
+@@ -1047,7 +1033,7 @@ enableFragmentOperationsAndDrawGeometry
+ 		glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
+ 		glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
+ 
+-		w->glDrawGeometry ();
++		w->vertexBuffer ()->render (transform, attrib);
+ 
+ 		texture->disable ();
+ 
+@@ -1057,7 +1043,7 @@ enableFragmentOperationsAndDrawGeometry
+ 	    }
+ 	    else
+ 	    {
+-		w->glDrawGeometry ();
++		w->vertexBuffer ()->render (transform, attrib);
+ 	    }
+ 
+ 	    texture->disable ();
+@@ -1074,9 +1060,9 @@ enableFragmentOperationsAndDrawGeometry
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
+ 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
+ 
+-	    constant[3] = attrib.getOpacity () / 65535.0f;
++	    constant[3] = attrib.opacity / 65535.0f;
+ 	    constant[0] = constant[1] = constant[2] = constant[3] *
+-			  attrib.getBrightness ()/ 65535.0f;
++			  attrib.brightness / 65535.0f;
+ 
+ 	    constant[0] = 0.5f + 0.5f * RED_SATURATION_WEIGHT   * constant[0];
+ 	    constant[1] = 0.5f + 0.5f * GREEN_SATURATION_WEIGHT * constant[1];
+@@ -1084,7 +1070,7 @@ enableFragmentOperationsAndDrawGeometry
+ 
+ 	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
+ 
+-	    w->glDrawGeometry ();
++	    w->vertexBuffer ()->render (transform, attrib);
+ 	}
+ 
+ 	texture->disable ();
+@@ -1097,9 +1083,6 @@ enableFragmentOperationsAndDrawGeometry
+ 
+ 	glColor4usv (defaultColor);
+ 	gs->setTexEnvMode (GL_REPLACE);
+-
+-	if (mask & PAINT_WINDOW_BLEND_MASK)
+-	    glDisable (GL_BLEND);
+     }
+     else
+     {
+@@ -1107,57 +1090,64 @@ enableFragmentOperationsAndDrawGeometry
+ 
+ 	if (mask & PAINT_WINDOW_BLEND_MASK)
+ 	{
+-	    glEnable (GL_BLEND);
+-	    if (attrib.getOpacity ()!= OPAQUE ||
+-		attrib.getBrightness () != BRIGHT)
++	    if (attrib.opacity != OPAQUE ||
++		attrib.brightness != BRIGHT)
+ 	    {
+ 		GLushort color;
+ 
+-		color = (attrib.getOpacity () * attrib.getBrightness ()) >> 16;
++		color = (attrib.opacity * attrib.brightness) >> 16;
+ 
+ 		gs->setTexEnvMode (GL_MODULATE);
+-		glColor4us (color, color, color, attrib.getOpacity ());
++		glColor4us (color, color, color, attrib.opacity);
+ 
+-		w->glDrawGeometry ();
++		w->vertexBuffer ()->render (transform, attrib);
+ 
+ 		glColor4usv (defaultColor);
+ 		gs->setTexEnvMode (GL_REPLACE);
+ 	    }
+ 	    else
+ 	    {
+-		w->glDrawGeometry ();
++		w->vertexBuffer ()->render (transform, attrib);
+ 	    }
+-
+-	    glDisable (GL_BLEND);
+ 	}
+-	else if (attrib.getBrightness () != BRIGHT)
++	else if (attrib.brightness != BRIGHT)
+ 	{
+ 	    gs->setTexEnvMode (GL_MODULATE);
+-	    glColor4us (attrib.getBrightness (), attrib.getBrightness (),
+-			attrib.getBrightness (), BRIGHT);
++	    glColor4us (attrib.brightness, attrib.brightness,
++			attrib.brightness, BRIGHT);
+ 
+-	    w->glDrawGeometry ();
++	    w->vertexBuffer ()->render (transform, attrib);
+ 
+ 	    glColor4usv (defaultColor);
+ 	    gs->setTexEnvMode (GL_REPLACE);
+ 	}
+ 	else
+ 	{
+-	    w->glDrawGeometry ();
++	    w->vertexBuffer ()->render (transform, attrib);
+ 	}
+ 
+ 	texture->disable ();
+     }
+ }
++#endif
+ 
+ void
+-GLWindow::glDrawTexture (GLTexture          *texture,
+-			 GLFragment::Attrib &attrib,
+-			 unsigned int       mask)
++GLWindow::glDrawTexture (GLTexture                 *texture,
++                         const GLMatrix            &transform,
++			 const GLWindowPaintAttrib &attrib,
++			 unsigned int              mask)
+ {
+-    WRAPABLE_HND_FUNCTN (glDrawTexture, texture, attrib, mask)
++    WRAPABLE_HND_FUNCTN (glDrawTexture, texture, transform, attrib, mask)
+ 
+     GLTexture::Filter filter;
++    GLboolean isBlendingEnabled = GL_FALSE;
++
++    // Enable blending if needed
++    if (mask & PAINT_WINDOW_BLEND_MASK) {
++	glGetBooleanv (GL_BLEND, &isBlendingEnabled);
++	if (!isBlendingEnabled)
++	    glEnable(GL_BLEND);
++    }
+ 
+     if (mask & (PAINT_WINDOW_TRANSFORMED_MASK |
+ 		PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK))
+@@ -1165,24 +1155,36 @@ GLWindow::glDrawTexture (GLTexture
+     else
+ 	filter = priv->gScreen->filter (NOTHING_TRANS_FILTER);
+ 
+-    if ((!attrib.hasFunctions () && (!priv->gScreen->lighting () ||
+-	 attrib.getSaturation () == COLOR || attrib.getSaturation () == 0)) ||
+-	!enableFragmentProgramAndDrawGeometry (priv->gScreen, this, texture,
+-					       attrib, filter, mask))
+-    {
+-	enableFragmentOperationsAndDrawGeometry (priv->gScreen, this, texture,
+-						 attrib, filter, mask);
+-    }
++    glActiveTexture(GL_TEXTURE0);
++    texture->enable (filter);
++
++    #ifdef USE_GLES
++    priv->vertexBuffer->render (transform, attrib);
++    #else
++
++    if (!GL::vbo && !GL::shaders)
++	enableLegacyOBSAndRender (priv->gScreen, this, texture, transform,
++                                  attrib, filter, mask);
++    else
++	priv->vertexBuffer->render (transform, attrib);
++    #endif
++
++    priv->shaders.clear ();
++    texture->disable ();
++
++    // Reset blending to old value
++    if ((mask & PAINT_WINDOW_BLEND_MASK) && !isBlendingEnabled)
++	glDisable(GL_BLEND);
+ }
+ 
+ bool
+-GLWindow::glDraw (const GLMatrix     &transform,
+-		  GLFragment::Attrib &fragment,
+-		  const CompRegion   &region,
+-		  unsigned int       mask)
++GLWindow::glDraw (const GLMatrix            &transform,
++		  const GLWindowPaintAttrib &attrib,
++		  const CompRegion          &region,
++		  unsigned int              mask)
+ {
+     WRAPABLE_HND_FUNCTN_RETURN (bool, glDraw, transform,
+-			      fragment, region, mask)
++			      attrib, region, mask)
+ 
+     const CompRegion &reg = (mask & PAINT_WINDOW_TRANSFORMED_MASK) ?
+                             infiniteRegion : region;
+@@ -1213,10 +1215,11 @@ GLWindow::glDraw (const GLMatrix     &tr
+     if (priv->textures.size () == 1)
+     {
+ 	ml[0] = priv->matrices[0];
+-	priv->geometry.reset ();
++	priv->vertexBuffer->begin ();
+ 	glAddGeometry (ml, priv->window->region (), reg);
+-	if (priv->geometry.vCount)
+-	    glDrawTexture (priv->textures[0], fragment, mask);
++	priv->vertexBuffer->end ();
++
++	glDrawTexture (priv->textures[0], transform, attrib, mask);
+     }
+     else
+     {
+@@ -1225,10 +1228,11 @@ GLWindow::glDraw (const GLMatrix     &tr
+ 	for (unsigned int i = 0; i < priv->textures.size (); i++)
+ 	{
+ 	    ml[0] = priv->matrices[i];
+-	    priv->geometry.reset ();
++	    priv->vertexBuffer->begin ();
+ 	    glAddGeometry (ml, priv->regions[i], reg);
+-	    if (priv->geometry.vCount)
+-		glDrawTexture (priv->textures[i], fragment, mask);
++	    priv->vertexBuffer->end ();
++
++	    glDrawTexture (priv->textures[i], transform, attrib, mask);
+ 	}
+     }
+ 
+@@ -1243,7 +1247,6 @@ GLWindow::glPaint (const GLWindowPaintAt
+ {
+     WRAPABLE_HND_FUNCTN_RETURN (bool, glPaint, attrib, transform, region, mask)
+ 
+-    GLFragment::Attrib fragment (attrib);
+     bool               status;
+ 
+     priv->lastPaint = attrib;
+@@ -1273,18 +1276,7 @@ GLWindow::glPaint (const GLWindowPaintAt
+     if (mask & PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
+ 	return true;
+ 
+-    if (mask & PAINT_WINDOW_TRANSFORMED_MASK ||
+-        mask & PAINT_WINDOW_WITH_OFFSET_MASK)
+-    {
+-	glPushMatrix ();
+-	glLoadMatrixf (transform.getMatrix ());
+-    }
+-
+-    status = glDraw (transform, fragment, region, mask);
+-
+-    if (mask & PAINT_WINDOW_TRANSFORMED_MASK ||
+-        mask & PAINT_WINDOW_WITH_OFFSET_MASK)
+-	glPopMatrix ();
++    status = glDraw (transform, attrib, region, mask);
+ 
+     return status;
+ }
+--- /dev/null
++++ compiz-0.9.7.6/plugins/opengl/src/shadercache.cpp
+@@ -0,0 +1,246 @@
++/*
++ * Copyright © 2012 Linaro Ltd.
++ *
++ * Permission to use, copy, modify, distribute, and sell this software
++ * and its documentation for any purpose is hereby granted without
++ * fee, provided that the above copyright notice appear in all copies
++ * and that both that copyright notice and this permission notice
++ * appear in supporting documentation, and that the name of
++ * Linaro Ltd. not be used in advertising or publicity pertaining to
++ * distribution of the software without specific, written prior permission.
++ * Linaro Ltd. makes no representations about the suitability of this
++ * software for any purpose. It is provided "as is" without express or
++ * implied warranty.
++ *
++ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
++ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
++ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
++ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
++ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
++ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++ *
++ * Authors: Alexandros Frantzis <[e-mail]>
++ */
++#include <map>
++#include <sstream>
++
++#include <opengl/shadercache.h>
++
++/** 
++ * Compares two GLShaderParameters objects.
++ */
++class GLShaderParametersComparer
++{
++public:
++    bool operator()(const GLShaderParameters &left, const GLShaderParameters &right) const
++    {
++        return left.hash() < right.hash();
++    }
++
++};
++
++typedef std::map<GLShaderParameters, GLShaderData, GLShaderParametersComparer> ShaderMapType;
++
++/** 
++ * Private data for GLPrivate
++ */
++class PrivateShaderCache
++{
++public:
++    PrivateShaderCache() {}
++
++    ShaderMapType::const_iterator addShaderData(const GLShaderParameters &params);
++
++    std::string createVertexShader (const GLShaderParameters &params);
++    std::string createFragmentShader (const GLShaderParameters &params);
++
++    ShaderMapType shaderMap;
++};
++
++/**********************
++ * GLShaderParameters *
++ **********************/
++
++int
++GLShaderParameters::hash() const
++{
++    return static_cast<int>(opacity) |
++           (static_cast<int>(brightness) << 1) |
++           (static_cast<int>(saturation) << 2) |
++           (static_cast<int>(color) << 3) |
++           (static_cast<int>(normal) << 5) |
++           (static_cast<int>(numTextures) << 8);
++}
++
++std::string
++GLShaderParameters::id() const
++{
++    std::stringstream ss;
++
++    ss << (opacity ? "t" : "f");
++    ss << (brightness ? "t" : "f");
++    ss << (saturation ? "t" : "f");
++    ss << (color == GLShaderVariableNone ? "n" :
++           color == GLShaderVariableUniform ? "u" : "v");
++
++    ss << (normal == GLShaderVariableNone ? "n" :
++           normal == GLShaderVariableUniform ? "u" : "v");
++    ss << numTextures;
++
++    return ss.str();