Merge lp:~smspillaz/compiz/gles2.fix_1001171 into lp:compiz/0.9.8

[Sam Spilsbury]

Fixes LP#1101171 ... at least for me.

1) Scale up the view matrix by 2 on each axis so that it matches the projection matrix when setting clip planes
2) Set the transformed bit on windows sliding on wall.

I am almost certain that #1 is the wrong approach here ... although I couldn't find anything else in the code that wasn't a value that it was supposed to be. Perhaps the projection matrix is setup differently?

#2 also shouldn't be necessary ... but is harmless and makes sense (moving windows ... different clip regions etc)

Unmerged revisions

3229. By Sam Spilsbury on 2012-05-26

Scale the plane clipping up to the projection matrix space and always
set the transformed bit on moving windows in wall

=== modified file 'cmake/CMakeLists.txt'
--- cmake/CMakeLists.txt	2012-05-24 00:55:17 +0000
+++ cmake/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -15,6 +15,8 @@
       plugin_extensions/CompizGenInstallData.cmake)
 list (APPEND _PluginExtensionFiles
       plugin_extensions/CompizGenInstallImages.cmake)
+list (APPEND _PluginExtensionFiles
+      plugin_extensions/CompizOpenGLFixups.cmake)
 
 if (USE_GCONF)
     list (APPEND _files CompizGconf.cmake)

=== modified file 'cmake/CompizCommon.cmake'
--- cmake/CompizCommon.cmake	2012-05-24 06:48:55 +0000
+++ cmake/CompizCommon.cmake	2012-05-26 15:11:19 +0000
@@ -18,6 +18,7 @@
 
 set (CMAKE_SKIP_RPATH FALSE)
 
+option (BUILD_GLES "Build against GLESv2 instead of GL" OFF)
 option (COMPIZ_BUILD_WITH_RPATH "Leave as ON unless building packages" ON)
 option (COMPIZ_RUN_LDCONFIG "Leave OFF unless you need to run ldconfig after install")
 option (COMPIZ_PACKAGING_ENABLED "Enable to manually set prefix, exec_prefix, libdir, includedir, datadir" OFF)
@@ -70,6 +71,17 @@
     set(IS_BZR_REPO 0)
 endif (IS_DIRECTORY ${CMAKE_SOURCE_DIR}/.bzr)
 
+set (USE_GLES ${BUILD_GLES})
+
+if (USE_GLES)
+    find_package(OpenGLES2)
+
+    if (NOT OPENGLES2_FOUND)
+	set (USE_GLES 0)
+	message (SEND_ERROR "OpenGLESv2 not found")
+    endif (NOT OPENGLES2_FOUND)
+endif (USE_GLES)
+
 function (compiz_ensure_linkage)
     find_program (LDCONFIG_EXECUTABLE ldconfig)
     mark_as_advanced (FORCE LDCONFIG_EXECUTABLE)

=== modified file 'cmake/CompizPlugin.cmake'
--- cmake/CompizPlugin.cmake	2012-05-24 00:55:17 +0000
+++ cmake/CompizPlugin.cmake	2012-05-26 15:11:19 +0000
@@ -257,6 +257,16 @@
 	    NO_DEFAULT_PATH
 	)
 
+	set (COMPIZ_CURRENT_PLUGIN ${plugin})
+	set (COMPIZ_CURRENT_XML_FILE ${_translated_xml})
+
+	# find extension files
+	file (GLOB _extension_files "${COMPIZ_CMAKE_MODULE_PATH}/plugin_extensions/*.cmake")
+
+	foreach (_file ${_extension_files})
+	    include (${_file})
+	endforeach ()
+
 	# generate pkgconfig file and install it and the plugin header file
 	if (_${plugin}_pkg AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include/${plugin})
 	    if ("${PLUGIN_BUILDTYPE}" STREQUAL "local")
@@ -269,11 +279,15 @@
 		    set (VERSION 0.0.1-git)
 		endif (NOT VERSION)
 
+		#add CFLAGSADD so pkg-config file has correct flags
+		set (COMPIZ_CFLAGS ${COMPIZ_CFLAGS} ${${_PLUGIN}_CFLAGSADD})
+
 		compiz_configure_file (
 		    ${_${plugin}_pkg}
 		    ${CMAKE_BINARY_DIR}/generated/compiz-${plugin}.pc
 		    COMPIZ_REQUIRES
 		    COMPIZ_CFLAGS
+		    PKGCONFIG_LIBS
 		)
 
 		install (
@@ -287,16 +301,6 @@
 	    endif ()
 	endif ()
 
-	set (COMPIZ_CURRENT_PLUGIN ${plugin})
-	set (COMPIZ_CURRENT_XML_FILE ${_translated_xml})
-
-	# find extension files
-	file (GLOB _extension_files "${COMPIZ_CMAKE_MODULE_PATH}/plugin_extensions/*.cmake")
-
-	foreach (_file ${_extension_files})
-	    include (${_file})
-	endforeach ()
-
 	# find files for build
 	file (GLOB _h_files "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")
 	file (GLOB _h_ins_files "${CMAKE_CURRENT_SOURCE_DIR}/include/${plugin}/*.h")

=== added file 'cmake/FindOpenGLES2.cmake'
--- cmake/FindOpenGLES2.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindOpenGLES2.cmake	2012-05-26 15:11:19 +0000
@@ -0,0 +1,51 @@
+# - Try to find OpenGLES
+# Once done this will define
+#  
+#  OPENGLES2_FOUND        - system has OpenGLES
+#  OPENGLES2_INCLUDE_DIR  - the GLES include directory
+#  OPENGLES2_LIBRARY	  - the GLES library
+#  OPENGLES2_LIBRARIES    - Link this to use OpenGLES
+#   
+
+FIND_PATH(OPENGLES2_INCLUDE_DIR GLES2/gl2.h
+  /usr/openwin/share/include
+  /opt/graphics/OpenGL/include /usr/X11R6/include
+  /usr/include
+)
+
+FIND_LIBRARY(OPENGLES2_LIBRARY
+  NAMES GLESv2
+  PATHS /opt/graphics/OpenGL/lib
+        /usr/openwin/lib
+        /usr/shlib /usr/X11R6/lib
+        /usr/lib
+)
+
+FIND_LIBRARY(OPENGLES2_EGL_LIBRARY
+    NAMES EGL
+    PATHS /usr/shlib /usr/X11R6/lib
+          /usr/lib
+)
+
+# On Unix OpenGL most certainly always requires X11.
+# Feel free to tighten up these conditions if you don't 
+# think this is always true.
+# It's not true on OSX.
+
+IF (OPENGLES2_LIBRARY)
+  IF(NOT X11_FOUND)
+    INCLUDE(FindX11)
+  ENDIF(NOT X11_FOUND)
+  IF (X11_FOUND)
+    IF (NOT APPLE)
+      SET (OPENGLES2_LIBRARIES ${X11_LIBRARIES})
+    ENDIF (NOT APPLE)
+  ENDIF (X11_FOUND)
+ENDIF(OPENGLES2_LIBRARY)
+
+SET( OPENGLES2_FOUND "NO" )
+IF(OPENGLES2_LIBRARY AND OPENGLES2_EGL_LIBRARY)
+    SET( OPENGLES2_LIBRARIES  ${OPENGLES2_LIBRARY} ${OPENGLES2_EGL_LIBRARY} ${OPENGLES2_LIBRARIES})
+    SET( OPENGLES2_FOUND "YES" )
+ENDIF(OPENGLES2_LIBRARY AND OPENGLES2_EGL_LIBRARY)
+

=== modified file 'cmake/base.cmake'
--- cmake/base.cmake	2012-05-24 00:55:17 +0000
+++ cmake/base.cmake	2012-05-26 15:11:19 +0000
@@ -24,6 +24,7 @@
     compiz_print_configure_header ("Compiz")
     compiz_color_message ("\n${_escape}[4mOptional features:${_escape}[0m\n")
 
+    compiz_print_result_message ("GLESv2" USE_GLES)
     compiz_print_result_message ("gtk window decorator" USE_GTK)
     compiz_print_result_message ("metacity theme support" USE_METACITY)
     compiz_print_result_message ("gconf schemas" USE_GCONF)
@@ -50,11 +51,13 @@
     endif ()
     install (FILES
 	     ${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindCompiz.cmake
+	     ${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindOpenGLES2.cmake
 	     DESTINATION
 	     ${CMAKE_INSTALL_PREFIX}/share/cmake-${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}/)
     add_custom_target (findcompiz_install
 	${CMAKE_COMMAND} -E make_directory ${CMAKE_ROOT}/Modules &&
 	${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/cmake/FindCompiz.cmake ${CMAKE_ROOT}/Modules
+	${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/cmake/FindOpenGLES2.cmake ${CMAKE_ROOT}/Modules
     )
     find_file (_find_compizconfig FindCompizConfig.cmake PATHS ${CMAKE_ROOT}/Modules ${ARGN})
     if (NOT _find_compizconfig)

=== added file 'cmake/plugin_extensions/CompizOpenGLFixups.cmake'
--- cmake/plugin_extensions/CompizOpenGLFixups.cmake	1970-01-01 00:00:00 +0000
+++ cmake/plugin_extensions/CompizOpenGLFixups.cmake	2012-05-26 15:11:19 +0000
@@ -0,0 +1,22 @@
+
+# modify pkg-config libs for opengl based on if we found GLES or not
+if (${COMPIZ_CURRENT_PLUGIN} STREQUAL "opengl")
+    if (USE_GLES)
+	set (PKGCONFIG_LIBS "-lGLESv2 -lEGL")
+    else (USE_GLES)
+	set (PKGCONFIG_LIBS "-lGL")
+    endif (USE_GLES)
+endif (${COMPIZ_CURRENT_PLUGIN} STREQUAL "opengl")
+
+# if plugin is using opengl plugin check for GLES library and set correct define
+if (NOT "${${_PLUGIN}_PLUGINDEPS}" STREQUAL "")
+    string (REGEX MATCH "opengl" opengl_found ${${_PLUGIN}_PLUGINDEPS})
+
+    if (opengl_found STREQUAL "opengl")
+	if (USE_GLES)
+	    set (${_PLUGIN}_CFLAGSADD ${${_PLUGIN}_CFLAGSADD} " -DUSE_GLES")
+	    string (REPLACE ";" " " ${_PLUGIN}_CFLAGSADD ${${_PLUGIN}_CFLAGSADD})
+	endif (USE_GLES)
+    endif (opengl_found STREQUAL "opengl")
+endif (NOT "${${_PLUGIN}_PLUGINDEPS}" STREQUAL "")
+

=== modified file 'include/core/wrapsystem.h'
--- include/core/wrapsystem.h	2012-05-14 16:55:59 +0000
+++ include/core/wrapsystem.h	2012-05-26 15:11:19 +0000
@@ -52,6 +52,10 @@
    }                                                    \
    enum { func ## Index = num };
 
+// For compatability ignore num and forward
+#define WRAPABLE_HND_FUNC(num, func, ...)				\
+    WRAPABLE_HND_FUNCTN(func, __VA_ARGS__)
+
 // New macro that doesn't need magic number
 #define WRAPABLE_HND_FUNCTN(func, ...)				        \
 {									\
@@ -69,6 +73,10 @@
     mCurrFunction[num] = curr;						\
 }
 
+// For compatability ignore num and forward
+#define WRAPABLE_HND_FUNC_RETURN(num, rtype, func, ...)			\
+    WRAPABLE_HND_FUNCTN_RETURN(rtype, func, __VA_ARGS__)
+
 // New macro that doesn't need magic number
 #define WRAPABLE_HND_FUNCTN_RETURN(rtype, func, ...)			\
 {									\

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2012-05-21 06:43:20 +0000
+++ plugins/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -24,4 +24,33 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/../logmessage/include
 )
 
+# temporarily disable plugins that aren't ported yed
+set (COMPIZ_DISABLE_PLUGIN_ANIMATIONADDON ON)
+set (COMPIZ_DISABLE_PLUGIN_BICUBIC ON)
+set (COMPIZ_DISABLE_PLUGIN_BLUR ON)
+set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)
+set (COMPIZ_DISABLE_PLUGIN_CUBEADDON ON)
+set (COMPIZ_DISABLE_PLUGIN_GEARS ON)
+set (COMPIZ_DISABLE_PLUGIN_GROUP ON)
+set (COMPIZ_DISABLE_PLUGIN_LOGINOUT ON)
+set (COMPIZ_DISABLE_PLUGIN_MAG ON)
+set (COMPIZ_DISABLE_PLUGIN_REFLEX ON)
+set (COMPIZ_DISABLE_PLUGIN_THUMBNAIL ON)
+set (COMPIZ_DISABLE_PLUGIN_WALLPAPER ON)
+
+# disable plugins which won't work on ES2 builds
+if (BUILD_GLES)
+
+    set (COMPIZ_DISABLE_PLUGIN_TD ON)
+    set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)
+    set (COMPIZ_DISABLE_PLUGIN_MBLUR ON)
+    set (COMPIZ_DISABLE_PLUGIN_BENCH ON)
+    set (COMPIZ_DISABLE_PLUGIN_FIREPAINT ON)
+    set (COMPIZ_DISABLE_PLUGIN_SHOWREPAINT ON)
+    set (COMPIZ_DISABLE_PLUGIN_WIDGET ON)
+    set (COMPIZ_DISABLE_PLUGIN_SHOWMOUSE ON)
+    set (COMPIZ_DISABLE_PLUGIN_SPLASH ON)
+
+endif (BUILD_GLES)
+
 compiz_add_plugins_in_folder (${CMAKE_CURRENT_SOURCE_DIR})

=== modified file 'plugins/animation/CMakeLists.txt'
--- plugins/animation/CMakeLists.txt	2012-05-16 17:40:41 +0000
+++ plugins/animation/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -1,7 +1,5 @@
 find_package (Compiz REQUIRED)
 include (CompizPlugin)
-include (FindOpenGL)
-
-if (OPENGL_GLU_FOUND)
-    compiz_plugin (animation PLUGINDEPS composite opengl LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
+
+compiz_plugin (animation PLUGINDEPS composite opengl)
+

=== modified file 'plugins/animation/include/animation/animation.h'
--- plugins/animation/include/animation/animation.h	2010-08-17 13:35:05 +0000
+++ plugins/animation/include/animation/animation.h	2012-05-26 15:11:19 +0000
@@ -3,8 +3,8 @@
 
 #define ANIMATION_ABI 20091205
 
+#include <core/core.h>
 #include <core/pluginclasshandler.h>
-#include <opengl/fragment.h>
 
 typedef enum
 {

=== modified file 'plugins/animation/include/animation/animeffect.h'
--- plugins/animation/include/animation/animeffect.h	2012-04-10 06:13:37 +0000
+++ plugins/animation/include/animation/animeffect.h	2012-05-26 15:11:19 +0000
@@ -72,7 +72,7 @@
     
     int mOverrideProgressDir;	///< 0: default dir, 1: forward, 2: backward
     
-    GLFragment::Attrib mCurPaintAttrib;
+    GLWindowPaintAttrib mCurPaintAttrib;
     GLushort mStoredOpacity;
     WindowEvent mCurWindowEvent;
     bool mInitialized; ///< whether the animation is initialized (in preparePaint)
@@ -160,7 +160,6 @@
 			    const CompRegion            &clip,
 			    unsigned int                maxGridWidth,
 			    unsigned int                maxGridHeight);
-    virtual void drawGeometry ();
 
     virtual bool paintWindowUsed () { return false; }
     virtual bool paintWindow (GLWindow			*gWindow,
@@ -178,9 +177,10 @@
     /// Should be overriden by a base animation class in every extension plugin.
     virtual ExtensionPluginInfo *getExtensionPluginInfo ();
 
-    void drawTexture (GLTexture          *texture,
-		      GLFragment::Attrib &attrib,
-		      unsigned int       mask);
+    void drawTexture (GLTexture                 *texture,
+                      const GLMatrix            &transform,
+                      const GLWindowPaintAttrib &attrib,
+                      unsigned int               mask);
 
     // Utility methods
 
@@ -205,7 +205,7 @@
 				  GLMatrix &transform);
     void setInitialized () { mInitialized = true; }
     inline bool initialized () { return mInitialized; }
-    inline void setCurPaintAttrib (GLFragment::Attrib &newAttrib)
+    inline void setCurPaintAttrib (const GLWindowPaintAttrib &newAttrib)
     { mCurPaintAttrib = newAttrib; }
 };
 #endif

=== modified file 'plugins/animation/include/animation/grid.h'
--- plugins/animation/include/animation/grid.h	2012-04-10 06:13:37 +0000
+++ plugins/animation/include/animation/grid.h	2012-05-26 15:11:19 +0000
@@ -78,8 +78,6 @@
     /// ( http://www.r3.nu/~cass/qcoord/ )
     bool mUseQTexCoord;
 
-    GLWindow::Geometry mGeometry; ///< geometry for grid mesh
-
     virtual bool using3D () { return false; }
 
     virtual bool requiresTransformedWindow () const { return true; }
@@ -103,6 +101,5 @@
 		      const CompRegion            &clip,
 		      unsigned int                maxGridWidth,
 		      unsigned int                maxGridHeight);
-    void drawGeometry ();
 };
 #endif

=== modified file 'plugins/animation/include/animation/multi.h'
--- plugins/animation/include/animation/multi.h	2012-05-21 08:50:26 +0000
+++ plugins/animation/include/animation/multi.h	2012-05-26 15:11:19 +0000
@@ -340,12 +340,6 @@
 		    (matrix, region, clip, maxGridWidth, maxGridHeight);
 	}
 
-	void drawGeometry ()
-	{
-	    setCurrAnimNumber (mAWindow, currentAnim);
-	    animList.at (currentAnim)->drawGeometry ();
-	}
-
 	bool paintWindowUsed ()
 	{
 	    int count = 0;

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2012-05-25 04:06:13 +0000
+++ plugins/animation/src/animation.cpp	2012-05-26 15:11:19 +0000
@@ -26,6 +26,10 @@
  * Particle system added by : (C) 2006 Dennis Kasprzyk
  * E-mail                   : [e-mail]
  *
+ * Ported to GLES by : Travis Watkins
+ *                     (C) 2011 Linaro Limited
+ * E-mail            : [e-mail]
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -80,8 +84,9 @@
  *
  */
 
-#include <GL/glu.h>
 #include <core/atoms.h>
+#include <core/core.h>
+#include <opengl/opengl.h>
 #include <sys/time.h>
 #include <assert.h>
 #include "private.h"
@@ -802,6 +807,58 @@
 		       coordsTransformed[GLVector::y]);
 }
 
+static bool
+project (float objx, float objy, float objz, 
+         GLMatrix modelview, GLMatrix projection,
+         const GLint viewport[4],
+         float *winx, float *winy, float *winz)
+{
+    unsigned int i;
+    float in[4];
+    float out[4];
+
+    in[0] = objx;
+    in[1] = objy;
+    in[2] = objz;
+    in[3] = 1.0;
+
+    for (i = 0; i < 4; i++) {
+	out[i] = 
+	    in[0] * modelview[i] +
+	    in[1] * modelview[4  + i] +
+	    in[2] * modelview[8  + i] +
+	    in[3] * modelview[12 + i];
+    }
+
+    for (i = 0; i < 4; i++) {
+	in[i] = 
+	    out[0] * projection[i] +
+	    out[1] * projection[4  + i] +
+	    out[2] * projection[8  + i] +
+	    out[3] * projection[12 + i];
+    }
+
+    if (in[3] == 0.0)
+	return false;
+
+    in[0] /= in[3];
+    in[1] /= in[3];
+    in[2] /= in[3];
+    /* Map x, y and z to range 0-1 */
+    in[0] = in[0] * 0.5 + 0.5;
+    in[1] = in[1] * 0.5 + 0.5;
+    in[2] = in[2] * 0.5 + 0.5;
+
+    /* Map x,y to viewport */
+    in[0] = in[0] * viewport[2] + viewport[0];
+    in[1] = in[1] * viewport[3] + viewport[1];
+
+    *winx = in[0];
+    *winy = in[1];
+    *winz = in[2];
+    return true;
+}
+
 /// Either points or objects should be non-0.
 bool
 AnimWindow::expandBBWithPoints3DTransform (CompOutput     &output,
@@ -810,14 +867,7 @@
 					   GridAnim::GridModel::GridObject *objects,
 					   unsigned int   nPoints)
 {
-    GLdouble dModel[16];
-    GLdouble dProjection[16];
-    GLdouble x, y, z;
-    for (unsigned int i = 0; i < 16; i++)
-    {
-	dModel[i] = transform[i];
-	dProjection[i] = GLScreen::get (::screen)->projectionMatrix ()[i];
-    }
+    GLfloat x, y, z;
     GLint viewport[4] =
 	{output.region ()->extents.x1,
 	 output.region ()->extents.y1,
@@ -828,9 +878,11 @@
     {
 	for (; nPoints; nPoints--, points += 3)
 	{
-	    if (!gluProject (points[0], points[1], points[2],
-			     dModel, dProjection, viewport,
-			     &x, &y, &z))
+	    if (!project (points[0], points[1], points[2],
+	                  transform,
+	                  *GLScreen::get (::screen)->projectionMatrix (),
+	                  viewport,
+	                  &x, &y, &z))
 		return false;
 
 	    expandBBWithPoint (x + 0.5, (::screen->height () - y) + 0.5);
@@ -841,11 +893,13 @@
 	GridAnim::GridModel::GridObject *object = objects;
 	for (; nPoints; nPoints--, object++)
 	{
-	    if (!gluProject (object->position ().x (),
-			     object->position ().y (),
-			     object->position ().z (),
-			     dModel, dProjection, viewport,
-			     &x, &y, &z))
+	    if (!project (object->position ().x (),
+	                  object->position ().y (),
+	                  object->position ().z (),
+	                  transform,
+	                  *GLScreen::get (::screen)->projectionMatrix (),
+	                  viewport,
+                          &x, &y, &z))
 		return false;
 
 	    expandBBWithPoint (x + 0.5, (::screen->height () - y) + 0.5);
@@ -1430,7 +1484,6 @@
 {
     gWindow->glPaintSetEnabled (this, enabling);
     gWindow->glAddGeometrySetEnabled (this, enabling);
-    gWindow->glDrawGeometrySetEnabled (this, enabling);
     gWindow->glDrawTextureSetEnabled (this, enabling);
 }
 
@@ -1503,46 +1556,28 @@
 }
 
 void
-PrivateAnimWindow::glDrawTexture (GLTexture          *texture,
-				  GLFragment::Attrib &attrib,
-				  unsigned int       mask)
+PrivateAnimWindow::glDrawTexture (GLTexture                 *texture,
+                                  const GLMatrix            &transform,
+                                  const GLWindowPaintAttrib &attrib,
+                                  unsigned int               mask)
 {
     if (mCurAnimation)
     {
 	mCurAnimation->setCurPaintAttrib (attrib);
     }
 
-    gWindow->glDrawTexture (texture, attrib, mask);
-}
-
-void
-PrivateAnimWindow::glDrawGeometry ()
-{
-    if (mCurAnimation)
-    {
-	if (mCurAnimation->initialized ())
-	    mCurAnimation->drawGeometry ();
-    }
-    else
-    {
-	gWindow->glDrawGeometry ();
-    }
-}
-
-void
-Animation::drawTexture (GLTexture          *texture,
-			GLFragment::Attrib &attrib,
-			unsigned int       mask)
+    gWindow->glDrawTexture (texture, transform, attrib, mask);
+}
+
+void
+Animation::drawTexture (GLTexture                *texture,
+                        const GLMatrix            &transform,
+                        const GLWindowPaintAttrib &attrib,
+                        unsigned int               mask)
 {
     mCurPaintAttrib = attrib;
 }
 
-void
-Animation::drawGeometry ()
-{
-    mAWindow->priv->gWindow->glDrawGeometry ();
-}
-
 bool
 PrivateAnimWindow::glPaint (const GLWindowPaintAttrib &attrib,
 			    const GLMatrix &transform,
@@ -1609,13 +1644,7 @@
 
     if (mCurAnimation->postPaintWindowUsed ())
     {
-	// Transform to make post-paint coincide with the window
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.getMatrix ());
-
 	mCurAnimation->postPaintWindow ();
-
-	glPopMatrix ();
     }
 
     return status;

=== modified file 'plugins/animation/src/grid.cpp'
--- plugins/animation/src/grid.cpp	2010-10-23 15:41:33 +0000
+++ plugins/animation/src/grid.cpp	2012-05-26 15:11:19 +0000
@@ -19,6 +19,10 @@
  * Hexagon tessellator added by : Mike Slegeir
  * E-mail                       : [e-mail]>
  *
+ * Ported to GLES by : Travis Watkins
+ *                     (C) 2011 Linaro Limited
+ * E-mail            : [e-mail]
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -36,6 +40,32 @@
 
 #include "private.h"
 
+// use the old structure then copy the data we want out of it
+class GridGeometry
+{
+    public:
+
+	GridGeometry () :
+	    vertices (NULL),
+	    vertexSize (0),
+	    vertexStride (0),
+	    vCount (0),
+	    texUnits (0),
+	    texCoordSize (0)
+	{
+	}
+
+    public:
+
+	GLfloat  *vertices;
+	int      vertexSize;
+	int      vertexStride;
+	int      vCount;
+	int      texUnits;
+	int      texCoordSize;
+};
+
+
 // =====================  Effect: Dodge  =========================
 
 GridAnim::GridModel::GridObject::GridObject () :
@@ -217,9 +247,9 @@
 		       unsigned int                maxGridWidth,
 		       unsigned int                maxGridHeight)
 {
+    GridGeometry geometry;
     unsigned int nMatrix = matrix.size ();
-    int nVertices, nIndices;
-    GLushort *i;
+    int nVertices;
     GLfloat *v;
     int x1, y1, x2, y2;
     float winContentsY, winContentsHeight;
@@ -234,8 +264,6 @@
     if (region.isEmpty ()) // nothing to do
 	return;
 
-    GLWindow::Geometry &geometry = GLWindow::get (mWindow)->geometry ();
-
     for (unsigned int it = 0; it < nMatrix; it++)
     {
 	if (matrix[it].xy != 0.0f || matrix[it].yx != 0.0f)
@@ -263,21 +291,14 @@
     winContentsHeight = oheight - outExtents.top - outExtents.bottom;
 
     geometry.texUnits = (int)nMatrix;
-
-    if (geometry.vCount == 0)
-    {
-	// reset
-	geometry.indexCount = 0;
-	geometry.texCoordSize = 4;
-    }
+    geometry.vertices = NULL;
+    geometry.vCount = 0;
+    geometry.texCoordSize = 4;
     geometry.vertexStride = 3 + geometry.texUnits * geometry.texCoordSize;
+
     vSize = geometry.vertexStride;
-
     nVertices = geometry.vCount;
-    nIndices = geometry.indexCount;
-
     v = geometry.vertices + (nVertices * vSize);
-    i = geometry.indices + nIndices;
 
     // For each clip passed to this function
     foreach (const CompRect &pClip, region.rects ())
@@ -315,38 +336,22 @@
 	nVertX = ceil ((x2 - x1) / gridW) + 2;
 	nVertY = (gridH ? ceil ((y2 - y1) / gridH) : 0) + 2;
 
-	// Allocate 4 indices for each quad
-	int newIndexSize = nIndices + ((nVertX - 1) * (nVertY - 1) * 4);
-
-	if (newIndexSize > geometry.indexSize)
-	{
-	    if (!geometry.moreIndices (newIndexSize))
-		return;
-
-	    i = geometry.indices + nIndices;
-	}
-	// Assign quad vertices to indices
-	for (int jy = 0; jy < nVertY - 1; jy++)
-	{
-	    for (int jx = 0; jx < nVertX - 1; jx++)
-	    {
-		*i++ = nVertices + nVertX * (2 * jy + 1) + jx;
-		*i++ = nVertices + nVertX * (2 * jy + 1) + jx + 1;
-		*i++ = nVertices + nVertX * 2 * jy + jx + 1;
-		*i++ = nVertices + nVertX * 2 * jy + jx;
-
-		nIndices += 4;
-	    }
-	}
-
 	// Allocate vertices
 	int newVertexSize =
 	    (nVertices + nVertX * (2 * nVertY - 2)) * vSize;
-	if (newVertexSize > geometry.vertexSize)
+	if (newVertexSize > geometry.vertexSize || geometry.vertices == NULL)
 	{
-	    if (!geometry.moreVertices (newVertexSize))
+	    if (geometry.vertices == NULL)
+		geometry.vertices = (GLfloat *)
+		                      malloc (sizeof (GLfloat) * newVertexSize);
+	    else
+		geometry.vertices = (GLfloat *)
+		  realloc (geometry.vertices, sizeof (GLfloat) * newVertexSize);
+
+	    if (!geometry.vertices)
 		return;
 
+	    geometry.vertexSize = newVertexSize;
 	    v = geometry.vertices + (nVertices * vSize);
 	}
 
@@ -588,52 +593,8 @@
 	    }
 	}
     }
+
     geometry.vCount = nVertices;
-    geometry.indexCount = nIndices;
-}
-
-void
-GridAnim::drawGeometry ()
-{
-    GLWindow::Geometry &geometry = GLWindow::get (mWindow)->geometry ();
-
-    int     texUnit = geometry.texUnits;
-    int     currentTexUnit = 0;
-    int     stride = geometry.vertexStride;
-    GLfloat *vertices = geometry.vertices + (stride - 3);
-
-    stride *= (int) sizeof (GLfloat);
-
-    glVertexPointer (3, GL_FLOAT, stride, vertices);
-
-    while (texUnit--)
-    {
-	if (texUnit != currentTexUnit)
-	{
-	    (*GL::clientActiveTexture) ((GLenum)(GL_TEXTURE0_ARB + texUnit));
-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-	    currentTexUnit = texUnit;
-	}
-	vertices -= geometry.texCoordSize;
-	glTexCoordPointer (geometry.texCoordSize,
-			   GL_FLOAT, stride, vertices);
-    }
-
-    glDrawElements (GL_QUADS, geometry.indexCount,
-		    GL_UNSIGNED_SHORT, geometry.indices);
-
-    // disable all texture coordinate arrays except 0
-    texUnit = geometry.texUnits;
-    if (texUnit > 1)
-    {
-	while (--texUnit)
-	{
-	    (*GL::clientActiveTexture) ((GLenum)(GL_TEXTURE0_ARB + texUnit));
-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-	}
-
-	(*GL::clientActiveTexture) (GL_TEXTURE0_ARB);
-    }
 }
 
 GridTransformAnim::GridTransformAnim (CompWindow *w,

=== modified file 'plugins/animation/src/private.h'
--- plugins/animation/src/private.h	2012-04-10 06:13:37 +0000
+++ plugins/animation/src/private.h	2012-05-26 15:11:19 +0000
@@ -407,9 +407,8 @@
     void glAddGeometry (const GLTexture::MatrixList &,
 			const CompRegion &, const CompRegion &,
 			unsigned int = MAXSHORT, unsigned int = MAXSHORT);
-    void glDrawTexture (GLTexture *texture, GLFragment::Attrib &,
-			unsigned int);
-    void glDrawGeometry ();
+    void glDrawTexture (GLTexture *texture, const GLMatrix &,
+                        const GLWindowPaintAttrib &, unsigned int);
 };
 
 class RollUpAnim :

=== modified file 'plugins/annotate/src/annotate.cpp'
--- plugins/annotate/src/annotate.cpp	2012-01-30 05:12:24 +0000
+++ plugins/annotate/src/annotate.cpp	2012-05-26 15:11:19 +0000
@@ -629,11 +629,14 @@
 
     if (status)
     {
+	GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+	GLfloat         vertexData[18];
+	GLfloat         textureData[12];
 	CompRect	rect;
 	GLMatrix	sTransform = transform;
 	int		numRect;
 	int		pos = 0;
-	float		vectorX, vectorY, offset;
+	float		offset;
 	int		angle;
 
 	offset = optionGetStrokeWidth () / 2;
@@ -641,10 +644,6 @@
 	/* This replaced prepareXCoords (s, output, -DEFAULT_Z_CAMERA) */
 	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
-	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
 	glEnable (GL_BLEND);
 
 	if (content && !region.isEmpty ())
@@ -656,34 +655,66 @@
 
 	        tex->enable (GLTexture::Fast);
 
-	        glBegin (GL_QUADS);
+	        streamingBuffer->begin (GL_TRIANGLES);
 
 	        while (numRect--)
 	        {
-	            glTexCoord2f (
-		        COMP_TEX_COORD_X (tex->matrix (), rect.at (pos).x1 ()),
-		        COMP_TEX_COORD_Y (tex->matrix (), rect.at (pos).y2 ()));
-	            glVertex2i (rect.at (pos).x1 (), rect.at (pos).y2 ());
-
-	            glTexCoord2f (
-		        COMP_TEX_COORD_X (tex->matrix (), rect.at (pos).x2 ()),
-		        COMP_TEX_COORD_Y (tex->matrix (), rect.at (pos).y2 ()));
-	            glVertex2i (rect.at (pos).x2 (), rect.at (pos).y2 ());
-
-	            glTexCoord2f (
-		        COMP_TEX_COORD_X (tex->matrix (), rect.at (pos).x2 ()),
-		        COMP_TEX_COORD_Y (tex->matrix (), rect.at (pos).y1 ()));
-	            glVertex2i (rect.at (pos).x2 (), rect.at (pos).y1 ());
-
-	            glTexCoord2f (
-		        COMP_TEX_COORD_X (tex->matrix (), rect.at (pos).x1 ()),
-		        COMP_TEX_COORD_Y (tex->matrix (), rect.at (pos).y1 ()));
-	            glVertex2i (rect.at (pos).x1 (), rect.at (pos).y1 ());
-
+		    GLfloat tx1 = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x1 ());
+		    GLfloat tx2 = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x2 ());
+		    GLfloat ty1 = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y1 ());
+		    GLfloat ty2 = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y2 ());
+
+		    vertexData[0]  = rect.at (pos).x1 ();
+		    vertexData[1]  = rect.at (pos).y1 ();
+		    vertexData[2]  = 0.0f;
+		    vertexData[3]  = rect.at (pos).x1 ();
+		    vertexData[4]  = rect.at (pos).y2 ();
+		    vertexData[5]  = 0.0f;
+		    vertexData[6]  = rect.at (pos).x2 ();
+		    vertexData[7]  = rect.at (pos).y1 ();
+		    vertexData[8]  = 0.0f;
+		    vertexData[9]  = rect.at (pos).x1 ();
+		    vertexData[10] = rect.at (pos).y2 ();
+		    vertexData[11] = 0.0f;
+
+		    vertexData[12] = rect.at (pos).x2 ();
+		    vertexData[13] = rect.at (pos).y2 ();
+		    vertexData[14] = 0.0f;
+
+		    vertexData[15] = rect.at (pos).x2 ();
+		    vertexData[16] = rect.at (pos).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;
+
+		    textureData[8]  = tx2;
+		    textureData[9]  = ty2;
+
+		    textureData[10] = tx2;
+		    textureData[11] = ty1;
+
+		    streamingBuffer->addVertices (6, vertexData);
+		    streamingBuffer->addTexCoords (0, 6, textureData);
 	            pos++;
 	        }
 
-	        glEnd ();
+		streamingBuffer->end ();
+		streamingBuffer->render (sTransform);
+
 	        tex->disable ();
 	    }
 	}
@@ -691,85 +722,132 @@
 	switch (drawMode)
 	{
 	case LineMode:
-	    glColor4usv (optionGetStrokeColor ());
 	    glLineWidth (optionGetStrokeWidth ());
-	    glBegin (GL_LINES);
-	    glVertex2i (initialPointerX, initialPointerY);
-	    glVertex2i (lineVector.x (), lineVector.y ());
-	    glEnd ();
+
+	    streamingBuffer->begin (GL_LINES);
+
+	    streamingBuffer->addColors (1, optionGetStrokeColor ());
+
+	    vertexData[0] = initialPointerX;
+	    vertexData[1] = initialPointerY;
+	    vertexData[2] = 0.0f;
+	    vertexData[3] = lineVector.x ();
+	    vertexData[4] = lineVector.y ();
+	    vertexData[5] = 0.0f;
+	    streamingBuffer->addVertices (2, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransform);
 	    break;
 
 	case RectangleMode:
+	    vertexData[0]  = rectangle.x1 ();
+	    vertexData[1]  = rectangle.y1 ();
+	    vertexData[2]  = 0.0f;
+	    vertexData[3]  = rectangle.x1 ();
+	    vertexData[4]  = rectangle.y2 ();
+	    vertexData[5]  = 0.0f;
+	    vertexData[6]  = rectangle.x2 ();
+	    vertexData[7]  = rectangle.y1 ();
+	    vertexData[8]  = 0.0f;
+	    vertexData[9]  = rectangle.x2 ();
+	    vertexData[10] = rectangle.y2 ();
+	    vertexData[11] = 0.0f;
+
 	    /* fill rectangle */
-	    glColor4usv (optionGetFillColor ());
-	    glRecti (rectangle.x1 (), rectangle.y2 (),
-		     rectangle.x2 (), rectangle.y1 ());
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    streamingBuffer->addColors (1, optionGetFillColor ());
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransform);
 
 	    /* draw rectangle outline */
-	    glColor4usv (optionGetStrokeColor ());
-	    glRecti (rectangle.x1 () - offset, rectangle.y2 (),
-		     rectangle.x1 () + offset, rectangle.y1 ());
+/*	    streamingBuffer->begin ();
+
+	    streamingBuffer->addColors (1, optionGetStrokeColor ());
+
+	    vertexData[0] = rectangle.x1 () - offset;
+	    vertexData[3] = rectangle.x1 () - offset;
+	    streamingBuffer->addVertices (4, vertexData);
+
 	    glRecti (rectangle.x2 () - offset, rectangle.y2 (),
 		     rectangle.x2 () + offset, rectangle.y1 ());
 	    glRecti (rectangle.x1 () - offset, rectangle.y1 () + offset,
 		     rectangle.x2 () + offset, rectangle.y1 () - offset);
 	    glRecti (rectangle.x1 () - offset, rectangle.y2 () + offset,
-		     rectangle.x2 () + offset, rectangle.y2 () - offset);
+		     rectangle.x2 () + offset, rectangle.y2 () - offset);*/
 	    break;
 
 	case EllipseMode:
 	    /* fill ellipse */
-	    glColor4usv (optionGetFillColor ());
-
-	    glBegin (GL_TRIANGLE_FAN);
-	    glVertex2d (ellipse.center.x (), ellipse.center.y ());
+	    streamingBuffer->begin (GL_TRIANGLE_FAN);
+
+	    streamingBuffer->addColors (1, optionGetFillColor ());
+
+	    vertexData[0] = ellipse.center.x ();
+	    vertexData[1] = ellipse.center.y ();
+	    vertexData[2] = 0.0f;
+	    streamingBuffer->addVertices (1, vertexData);
+
 	    for (angle = 0; angle <= 360; angle += 1)
 	    {
-		vectorX = ellipse.center.x () +
-			 (ellipse.radiusX * sinf (angle * DEG2RAD));
-		vectorY = ellipse.center.y () +
-			 (ellipse.radiusY * cosf (angle * DEG2RAD));
-		glVertex2d (vectorX, vectorY);
+		vertexData[0] = ellipse.center.x () +
+		                (ellipse.radiusX * sinf (angle * DEG2RAD));
+		vertexData[1] = ellipse.center.y () +
+		                (ellipse.radiusY * cosf (angle * DEG2RAD));
+		streamingBuffer->addVertices (1, vertexData);
 	    }
-	    glVertex2d (ellipse.center.x (), ellipse.center.y () +
-			ellipse.radiusY);
-	    glEnd();
+
+	    vertexData[0] = ellipse.center.x ();
+	    vertexData[1] = ellipse.center.y () + ellipse.radiusY;
+	    streamingBuffer->addVertices (1, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransform);
 
 	    /* draw ellipse outline */
-	    glColor4usv (optionGetStrokeColor ());
 	    glLineWidth (optionGetStrokeWidth ());
 
-	    glBegin (GL_TRIANGLE_STRIP);
-	    glVertex2d (ellipse.center.x (), ellipse.center.y () +
-			ellipse.radiusY - offset);
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    streamingBuffer->addColors (1, optionGetStrokeColor ());
+
+
+	    vertexData[0] = ellipse.center.x ();
+	    vertexData[1] = ellipse.center.y () + ellipse.radiusY - offset;
+	    vertexData[2] = 0.0f;
+	    streamingBuffer->addVertices (1, vertexData);
+
 	    for (angle = 360; angle >= 0; angle -= 1)
 	    {
-		vectorX = ellipse.center.x () + ((ellipse.radiusX -
-			  offset) * sinf (angle * DEG2RAD));
-		vectorY = ellipse.center.y () + ((ellipse.radiusY -
-			  offset) * cosf (angle * DEG2RAD));
-		glVertex2d (vectorX, vectorY);
-		vectorX = ellipse.center.x () + ((ellipse.radiusX +
-			  offset) * sinf (angle * DEG2RAD));
-		vectorY = ellipse.center.y () + ((ellipse.radiusY +
-			  offset) * cosf (angle * DEG2RAD));
-		glVertex2d (vectorX, vectorY);
+		vertexData[0] = ellipse.center.x () + ((ellipse.radiusX -
+		                offset) * sinf (angle * DEG2RAD));
+		vertexData[1] = ellipse.center.y () + ((ellipse.radiusY -
+				offset) * cosf (angle * DEG2RAD));
+		vertexData[2] = 0.0f;
+		vertexData[3] = ellipse.center.x () + ((ellipse.radiusX +
+		                offset) * sinf (angle * DEG2RAD));
+		vertexData[4] = ellipse.center.y () + ((ellipse.radiusY +
+		                offset) * cosf (angle * DEG2RAD));
+		vertexData[5] = 0.0f;
+		streamingBuffer->addVertices (2, vertexData);
 	    }
-	    glVertex2d (ellipse.center.x (), ellipse.center.y () +
-			ellipse.radiusY + offset);
-	    glEnd();
+
+	    vertexData[0] = ellipse.center.x ();
+	    vertexData[1] = ellipse.center.y () + ellipse.radiusY + offset;
+	    streamingBuffer->addVertices (1, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransform);
 	    break;
 
 	default:
 	    break;
 	}
 
-	/* clean up */
-	glColor4usv (defaultColor);
 	glDisable (GL_BLEND);
-	glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-
-	glPopMatrix ();
     }
 
     return status;

=== modified file 'plugins/blur/CMakeLists.txt'
--- plugins/blur/CMakeLists.txt	2011-01-24 06:28:52 +0000
+++ plugins/blur/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -2,15 +2,15 @@
 
 include (CompizPlugin)
 
-find_package (OpenGL)
-
-if (OPENGL_GLU_FOUND)
-    compiz_plugin(blur PLUGINDEPS composite opengl LIBRARIES decoration ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-
-    if (COMPIZ_BUILD_WITH_RPATH AND NOT COMPIZ_DISABLE_PLUGIN_BLUR)
-	set_target_properties (
-	    blur PROPERTIES
-	    INSTALL_RPATH "${COMPIZ_LIBDIR}"
-	)
-    endif (COMPIZ_BUILD_WITH_RPATH AND NOT COMPIZ_DISABLE_PLUGIN_BLUR)
-endif ()
+#find_package (OpenGL)
+
+#if (OPENGL_GLU_FOUND)
+#    compiz_plugin(blur PLUGINDEPS composite opengl LIBRARIES decoration ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
+
+#    if (COMPIZ_BUILD_WITH_RPATH AND NOT COMPIZ_DISABLE_PLUGIN_BLUR)
+#	set_target_properties (
+#	    blur PROPERTIES
+#	    INSTALL_RPATH "${COMPIZ_LIBDIR}"
+#	)
+#    endif (COMPIZ_BUILD_WITH_RPATH AND NOT COMPIZ_DISABLE_PLUGIN_BLUR)
+#endif ()

=== modified file 'plugins/clone/src/clone.cpp'
--- plugins/clone/src/clone.cpp	2010-02-04 17:16:02 +0000
+++ plugins/clone/src/clone.cpp	2012-05-26 15:11:19 +0000
@@ -295,9 +295,6 @@
 			 0.0f);
 	sTransform.scale (zoomX, zoomY, 1.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
 	filter = gScreen->textureFilter ();
 
 	if (offset == 0.0f)
@@ -325,8 +322,6 @@
 	}
 
 	gScreen->setTextureFilter (filter);
-
-	glPopMatrix ();
     }
 
     return status;

=== modified file 'plugins/compiztoolbox/src/compiztoolbox.cpp'
--- plugins/compiztoolbox/src/compiztoolbox.cpp	2012-01-18 16:26:45 +0000
+++ plugins/compiztoolbox/src/compiztoolbox.cpp	2012-05-26 15:11:19 +0000
@@ -465,9 +465,7 @@
 	sAttrib.yTranslate = wy - g.y () +
 			     window->border ().top  * sAttrib.yScale;
 
-	GLFragment::Attrib fragment (sAttrib);
-
-	if (window->alpha () || fragment.getOpacity () != OPAQUE)
+	if (window->alpha () || sAttrib.opacity != OPAQUE)
 	    mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
 
 	wTransform.translate (g.x (), g.y (), 0.0f);
@@ -476,9 +474,6 @@
 			      sAttrib.yTranslate / sAttrib.yScale - g.y (),
 			      0.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.getMatrix ());
-
 	filter = gScreen->textureFilter ();
 
 	if (baseScreen->getMipmap ())
@@ -488,13 +483,11 @@
 	   very ugly but necessary until the vertex stage has been made
 	   fully pluggable. */
 	gWindow->glAddGeometrySetCurrentIndex (MAXSHORT);
-	gWindow->glDraw (wTransform, fragment, infiniteRegion, mask);
+	gWindow->glDraw (wTransform, sAttrib, infiniteRegion, mask);
 	gWindow->glAddGeometrySetCurrentIndex (addWindowGeometryIndex);
 
 	gScreen->setTextureFilter (filter);
 
-	glPopMatrix ();
-
 	if (iconMode != HideIcon)
 	{
 	    icon = gWindow->getIcon (MAX_ICON_SIZE, MAX_ICON_SIZE);
@@ -535,30 +528,23 @@
 	sAttrib.xTranslate = wx - g.x ();
 	sAttrib.yTranslate = wy - g.y ();
 
-	gWindow->geometry ().reset ();
+	gWindow->vertexBuffer ()->begin ();
 
 	gWindow->glAddGeometrySetCurrentIndex (MAXSHORT);
 	gWindow->glAddGeometry (matrix, iconReg, infiniteRegion);
 	gWindow->glAddGeometrySetCurrentIndex (addWindowGeometryIndex);
 
-	if (gWindow->geometry ().vCount)
-	{
-	    GLFragment::Attrib fragment (sAttrib);
-	    GLMatrix           wTransform (transform);
-
-	    wTransform.translate (g.x (), g.y (), 0.0f);
-	    wTransform.scale (sAttrib.xScale, sAttrib.yScale, 1.0f);
-	    wTransform.translate (sAttrib.xTranslate / sAttrib.xScale - g.x (),
-				  sAttrib.yTranslate / sAttrib.yScale - g.y (),
-				  0.0f);
-
-	    glPushMatrix ();
-	    glLoadMatrixf (wTransform.getMatrix ());
-
-	    gWindow->glDrawTexture (icon, fragment, mask);
-
-	    glPopMatrix ();
-	}
+	gWindow->vertexBuffer ()->end ();
+
+	GLMatrix           wTransform (transform);
+
+	wTransform.translate (g.x (), g.y (), 0.0f);
+	wTransform.scale (sAttrib.xScale, sAttrib.yScale, 1.0f);
+	wTransform.translate (sAttrib.xTranslate / sAttrib.xScale - g.x (),
+	                      sAttrib.yTranslate / sAttrib.yScale - g.y (),
+	                      0.0f);
+
+	gWindow->glDrawTexture (icon, wTransform, sAttrib, mask);
     }
 }
 

=== modified file 'plugins/copytex/src/copytex.cpp'
--- plugins/copytex/src/copytex.cpp	2011-06-01 03:33:04 +0000
+++ plugins/copytex/src/copytex.cpp	2012-05-26 15:11:19 +0000
@@ -112,6 +112,14 @@
     GLenum            target;
     GLTexture::Matrix matrix = _identity_matrix;
 
+#ifdef USE_GLES
+    target = GL_TEXTURE_2D;
+    matrix.xx = 1.0f / dim.width ();
+    matrix.yy = 1.0f / dim.height ();
+    matrix.x0 = -dim.x () * matrix.xx;
+    matrix.y0 = -dim.y () * matrix.yy;
+#else
+
     if (GL::textureNonPowerOfTwo ||
 	(POWER_OF_TWO (dim.width ()) && POWER_OF_TWO (dim.height ())))
     {
@@ -129,6 +137,7 @@
 	matrix.x0 = -dim.x ();
 	matrix.y0 = -dim.y ();
     }
+#endif
 
     setData (target, matrix, false);
     setGeometry (dim.x1 (), dim.y1 (), dim.x2 () - dim.x1 (), dim.y2 () - dim.y1 ());

=== modified file 'plugins/cube/CMakeLists.txt'
--- plugins/cube/CMakeLists.txt	2009-11-03 20:14:43 +0000
+++ plugins/cube/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -2,4 +2,4 @@
 
 include (CompizPlugin)
 
-compiz_plugin(cube PLUGINDEPS composite opengl)
\ No newline at end of file
+compiz_plugin(cube PLUGINDEPS composite opengl)

=== modified file 'plugins/cube/include/cube/cube.h'
--- plugins/cube/include/cube/cube.h	2012-01-18 16:26:45 +0000
+++ plugins/cube/include/cube/cube.h	2012-05-26 15:11:19 +0000
@@ -62,15 +62,18 @@
 	virtual void cubePaintTop (const GLScreenPaintAttrib &sAttrib,
 				   const GLMatrix            &transform,
 				   CompOutput                *output,
-				   int                       size);
+				   int                       size,
+				   const GLVector            &normal);
 	virtual void cubePaintBottom (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size);
+				      int                       size,
+				      const GLVector            &normal);
 	virtual void cubePaintInside (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size);
+				      int                       size,
+				      const GLVector            &normal);
 	virtual bool cubeCheckOrientation (const GLScreenPaintAttrib &sAttrib,
 					   const GLMatrix            &transform,
 					   CompOutput                *output,
@@ -120,13 +123,13 @@
 		      float, float);
 	WRAPABLE_HND (2, CubeScreenInterface, void, cubePaintTop,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (3, CubeScreenInterface, void, cubePaintBottom,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (4, CubeScreenInterface, void, cubePaintInside,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (5, CubeScreenInterface, bool, cubeCheckOrientation,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
 		      CompOutput *, std::vector<GLVector> &);

=== modified file 'plugins/cube/src/cube.cpp'
--- plugins/cube/src/cube.cpp	2012-01-16 09:50:28 +0000
+++ plugins/cube/src/cube.cpp	2012-05-26 15:11:19 +0000
@@ -55,22 +55,25 @@
 CubeScreenInterface::cubePaintTop (const GLScreenPaintAttrib &sAttrib,
 		                   const GLMatrix            &transform,
 		                   CompOutput                *output,
-		                   int                       size)
-    WRAPABLE_DEF (cubePaintTop, sAttrib, transform, output, size)
+				   int                       size,
+				   const GLVector            &normal)
+    WRAPABLE_DEF (cubePaintTop, sAttrib, transform, output, size, normal)
     
 void
 CubeScreenInterface::cubePaintBottom (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size)
-    WRAPABLE_DEF (cubePaintBottom, sAttrib, transform, output, size)
+				      int                       size,
+				      const GLVector            &normal)
+    WRAPABLE_DEF (cubePaintBottom, sAttrib, transform, output, size, normal)
 
 void
 CubeScreenInterface::cubePaintInside (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size)
-    WRAPABLE_DEF (cubePaintInside, sAttrib, transform, output, size)
+				      int                       size,
+				      const GLVector            &normal)
+    WRAPABLE_DEF (cubePaintInside, sAttrib, transform, output, size, normal)
 
 bool
 CubeScreenInterface::cubeCheckOrientation (const GLScreenPaintAttrib &sAttrib,
@@ -433,6 +436,7 @@
     }
 }
 
+#ifndef USE_GLES
 static bool
 fillCircleTable (GLfloat   **ppSint,
 		 GLfloat   **ppCost,
@@ -467,10 +471,12 @@
 
     return true;
 }
+#endif
 
 void
 PrivateCubeScreen::updateSkydomeList (GLfloat fRadius)
 {
+#ifndef USE_GLES
     GLint   iSlices = 128;
     GLint   iStacks = 64;
     GLfloat afTexCoordX[4];
@@ -532,6 +538,7 @@
     afTexCoordX[3] = 1.0f;
     afTexCoordY[3] = 1.0f;
 
+
     if (!mSkyListId)
 	mSkyListId = glGenLists (1);
 
@@ -616,6 +623,8 @@
     free (cost1);
     free (sint2);
     free (cost2);
+
+#endif
 }
 
 bool
@@ -818,7 +827,7 @@
 {
     WRAPABLE_HND_FUNCTN_RETURN (bool, cubeCheckOrientation, sAttrib, transform, output, points)
     GLMatrix sTransform = transform;
-    GLMatrix mvp, pm (priv->gScreen->projectionMatrix ());
+    GLMatrix mvp, pm (priv->gScreen->projectionMatrix ()->getMatrix ());
     GLVector pntA, pntB, pntC;
     GLVector vecA, vecB, ortho;
     bool     rv = false;
@@ -1063,7 +1072,7 @@
     if (priv->mSky.size () > 0)
     {
 	priv->gScreen->setLighting (false);
-
+#ifndef USE_GLES
 	glPushMatrix ();
 
 	if (priv->optionGetSkydomeAnimated () &&
@@ -1079,6 +1088,7 @@
 
 	glCallList (priv->mSkyListId);
 	glPopMatrix ();
+#endif
     }
     else
     {
@@ -1090,9 +1100,10 @@
 CubeScreen::cubePaintTop (const GLScreenPaintAttrib &sAttrib,
 			  const GLMatrix            &transform,
 			  CompOutput                *output,
-			  int                       size)
+			  int                       size,
+			  const GLVector            &normal)
 {
-    WRAPABLE_HND_FUNCTN (cubePaintTop, sAttrib, transform, output, size)
+    WRAPABLE_HND_FUNCTN (cubePaintTop, sAttrib, transform, output, size, normal)
 
     GLScreenPaintAttrib sa = sAttrib;
     GLMatrix            sTransform = transform;
@@ -1105,51 +1116,49 @@
     color = priv->optionGetTopColor ();
     opacity = priv->mDesktopOpacity * color[3] / 0xffff;
 
-    glColor4us (color[0] * opacity / 0xffff,
-		color[1] * opacity / 0xffff,
-		color[2] * opacity / 0xffff,
-		opacity);
+    GLVertexBuffer	  *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+    std::vector <GLushort> colorData;
 
-    glPushMatrix ();
+    colorData.push_back (color[0] * opacity / 0xffff);
+    colorData.push_back (color[1] * opacity / 0xffff);
+    colorData.push_back (color[2] * opacity / 0xffff);
+    colorData.push_back (opacity);
 
     sa.yRotate += (360.0f / size) * (priv->mXRotations + 1);
 
     priv->gScreen->glApplyTransform (sa, output, &sTransform);
 
-    glLoadMatrixf (sTransform.getMatrix ());
-    glTranslatef (priv->mOutputXOffset, -priv->mOutputYOffset, 0.0f);
-    glScalef (priv->mOutputXScale, priv->mOutputYScale, 1.0f);
+    sTransform.translate (priv->mOutputXOffset, -priv->mOutputYOffset, 0.0f);
+    sTransform.scale (priv->mOutputXScale, priv->mOutputYScale, 1.0f);
 
     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
     {
+#ifndef USE_GLES
 	priv->gScreen->setTexEnvMode (GL_MODULATE);
-	glEnable (GL_BLEND);
+#endif
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
-    glVertexPointer (3, GL_FLOAT, 0, priv->mVertices);
+    bool withTexture = priv->mInvert == 1 && size == 4 && priv->mTexture.size ();
 
-    if (priv->mInvert == 1 && size == 4 && priv->mTexture.size ())
-    {
+    if (withTexture)
 	priv->mTexture[0]->enable (GLTexture::Good);
-	glTexCoordPointer (2, GL_FLOAT, 0, priv->mTc);
-	glDrawArrays (GL_TRIANGLE_FAN, 0, priv->mNVertices >> 1);
+
+    streamingBuffer->begin (GL_TRIANGLE_FAN);
+    streamingBuffer->addColors (1, &(colorData[0]));
+    streamingBuffer->addVertices (priv->mNVertices >> 1, priv->mVertices);
+    streamingBuffer->addNormals (1, const_cast <GLfloat *> (&normal[0]));
+
+    if (withTexture)
+	streamingBuffer->addTexCoords (0, 2, priv->mTc);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (sTransform);
+
+    if (withTexture)
 	priv->mTexture[0]->disable ();
-	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-    }
-    else
-    {
-	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-	glDrawArrays (GL_TRIANGLE_FAN, 0, priv->mNVertices >> 1);
-    }
-
-    glPopMatrix ();
-
-    glColor4usv (defaultColor);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
     priv->gScreen->setTexEnvMode (GL_REPLACE);
-    glDisable (GL_BLEND);
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
@@ -1157,9 +1166,10 @@
 CubeScreen::cubePaintBottom (const GLScreenPaintAttrib &sAttrib,
 			     const GLMatrix            &transform,
 			     CompOutput                *output,
-			     int                       size)
+			     int                       size,
+			     const GLVector            &normal)
 {
-    WRAPABLE_HND_FUNCTN (cubePaintBottom, sAttrib, transform, output, size)
+    WRAPABLE_HND_FUNCTN (cubePaintBottom, sAttrib, transform, output, size, normal)
 
     GLScreenPaintAttrib sa = sAttrib;
     GLMatrix            sTransform = transform;
@@ -1172,41 +1182,40 @@
     color   = priv->optionGetBottomColor ();
     opacity = priv->mDesktopOpacity * color[3] / 0xffff;
 
-    glColor4us (color[0] * opacity / 0xffff,
-		color[1] * opacity / 0xffff,
-		color[2] * opacity / 0xffff,
-		opacity);
+    GLVertexBuffer	  *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+    std::vector <GLushort> colorData;
 
-    glPushMatrix ();
+    colorData.push_back (color[0] * opacity / 0xffff);
+    colorData.push_back (color[1] * opacity / 0xffff);
+    colorData.push_back (color[2] * opacity / 0xffff);
+    colorData.push_back (opacity);
 
     sa.yRotate += (360.0f / size) * (priv->mXRotations + 1);
 
     priv->gScreen->glApplyTransform (sa, output, &sTransform);
 
-    glLoadMatrixf (sTransform.getMatrix ());
-    glTranslatef (priv->mOutputXOffset, -priv->mOutputYOffset, 0.0f);
-    glScalef (priv->mOutputXScale, priv->mOutputYScale, 1.0f);
+    sTransform.translate (priv->mOutputXOffset, -priv->mOutputYOffset, 0.0f);
+    sTransform.scale (priv->mOutputXScale, priv->mOutputYScale, 1.0f);
 
     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
     {
+#ifndef USE_GLES
 	priv->gScreen->setTexEnvMode (GL_MODULATE);
-	glEnable (GL_BLEND);
+#endif
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
-    glVertexPointer (3, GL_FLOAT, 0, priv->mVertices);
-
-
-    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-    glDrawArrays (GL_TRIANGLE_FAN, priv->mNVertices >> 1, priv->mNVertices >> 1);
-
-    glPopMatrix ();
-
-    glColor4usv (defaultColor);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+    streamingBuffer->begin (GL_TRIANGLE_FAN);
+    streamingBuffer->addColors (1, &(colorData[0]));
+    streamingBuffer->addVertices (priv->mNVertices, priv->mVertices);
+    streamingBuffer->addNormals (1, const_cast <GLfloat *> (&normal[0]));
+    streamingBuffer->setVertexOffset (priv->mNVertices >> 1);
+    streamingBuffer->setMaxVertices (priv->mNVertices >> 1);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (sTransform);
 
     priv->gScreen->setTexEnvMode (GL_REPLACE);
-    glDisable (GL_BLEND);
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
@@ -1214,9 +1223,10 @@
 CubeScreen::cubePaintInside (const GLScreenPaintAttrib &sAttrib,
 			     const GLMatrix            &transform,
 			     CompOutput                *output,
-			     int                       size)
+			     int                       size,
+			     const GLVector            &normal)
 {
-    WRAPABLE_HND_FUNCTN (cubePaintInside, sAttrib, transform, output, size)
+    WRAPABLE_HND_FUNCTN (cubePaintInside, sAttrib, transform, output, size, normal)
 }
 
 void 
@@ -1226,6 +1236,8 @@
 {
     if (mRotationState != CubeScreen::RotationNone)
     {
+	/* FIXME: No output clipping in OpenGL|ES yet */
+	#ifndef USE_GLES
 	glPushMatrix ();
 	glLoadMatrixf (transform.getMatrix ());
 	glTranslatef (mOutputXOffset, -mOutputYOffset, 0.0f);
@@ -1260,6 +1272,7 @@
 	glEnable (GL_CLIP_PLANE3);
 
 	glPopMatrix ();
+	#endif
     }
     else
 	gScreen->glEnableOutputClipping (transform, region, output);
@@ -1447,38 +1460,28 @@
 
 	if (topDir && bottomDir)
 	{
-	    glNormal3f (0.0f, -1.0f, 0.0f);
 	    if (allCaps)
 	    {
-		cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize);
-		glNormal3f (0.0f, 0.0f, -1.0f);
-		cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize);
-		glNormal3f (0.0f, -1.0f, 0.0f);
+		cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize, GLVector (0.0f, -1.0f, 0.0f, 1.0f));
+		cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize, GLVector (0.0f, 0.0f, -1.0f, 1.0f));
 	    }
-	    cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize);
+	    cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize, GLVector (0.0f, -1.0f, 0.0f, 1.0f));
 	}
 	else if (!topDir && !bottomDir)
 	{
-	    glNormal3f (0.0f, 1.0f, 0.0f);
 	    if (allCaps)
 	    {
-		cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize);
-		glNormal3f (0.0f, 0.0f, -1.0f);
-		cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize);
-		glNormal3f (0.0f, 1.0f, 0.0f);
+		cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize, GLVector (0.0f, 1.0f, 0.0f, 1.0f));
+		cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize, GLVector (0.0f, 0.0f, -1.0f, 1.0f));
 	    }
-	    cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize);
+	    cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize, GLVector (0.0f, -1.0f, 0.0f, 1.0f));
 	}
 	else if (allCaps)
 	{
-	    glNormal3f (0.0f, 1.0f, 0.0f);
-	    cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize);
-	    glNormal3f (0.0f, -1.0f, 0.0f);
-	    cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize);
-	    glNormal3f (0.0f, 0.0f, -1.0f);
-	    cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize);
+	    cubeScreen->cubePaintTop (sa, transform, outputPtr, hsize, GLVector (0.0f, 1.0f, 0.0f, 1.0f));
+	    cubeScreen->cubePaintBottom (sa, transform, outputPtr, hsize, GLVector (0.0f, -1.0f, 0.0f, 1.0f));
+	    cubeScreen->cubePaintInside (sa, transform, outputPtr, hsize, GLVector (0.0f, 0.0f, -1.0f, 1.0f));
 	}
-	glNormal3f (0.0f, 0.0f, -1.0f);
     }
 
     if (wasCulled)
@@ -1705,8 +1708,10 @@
     if (mVertices)
 	free (mVertices);
 
+#ifndef USE_GLES
     if (mSkyListId)
 	glDeleteLists (mSkyListId, 1);
+#endif
 }
 
 

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/decor.cpp	2012-05-26 15:11:19 +0000
@@ -177,15 +177,13 @@
  */
 
 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,15 +203,19 @@
 	}
     }
 
+    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)
 {
+    GLboolean isBlendingEnabled;
+
     if (wd &&
 	wd->decor->type == WINDOW_DECORATION_TYPE_PIXMAP)
     {
@@ -221,6 +223,7 @@
 	GLTexture::MatrixList ml (1);
 	mask |= PAINT_WINDOW_BLEND_MASK;
 
+	gWindow->vertexBuffer ()->begin ();
 	const CompRegion *preg = NULL;
 
 	if ((mask & (PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK |
@@ -247,8 +250,6 @@
 
 	const CompRegion &reg (*preg);
 
-	gWindow->geometry ().reset ();
-
 	if (updateMatrix)
 	    updateDecorationScale ();
 
@@ -267,9 +268,14 @@
 	    }
 	}
 
-	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 && wd->decor->type == WINDOW_DECORATION_TYPE_WINDOW)
     {
@@ -282,15 +288,18 @@
 
 	if (updateMatrix)
 	    updateDecorationScale ();
+	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 (), region);
+	    gWindow->vertexBuffer ()->end ();
 
-	    if (gWindow->geometry ().vCount)
-		gWindow->glDrawTexture (gWindow->textures ()[0], attrib, mask);
+	    gWindow->glDrawTexture (gWindow->textures ()[0], transform,
+	                            attrib, mask);
 	}
 	else
 	{
@@ -299,14 +308,17 @@
 	    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], region);
+		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);
     }
 }
 

=== modified file 'plugins/decor/src/decor.h'
--- plugins/decor/src/decor.h	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/decor.h	2012-05-26 15:11:19 +0000
@@ -276,10 +276,10 @@
 
 	bool damageRect (bool, const CompRect &);
 
-	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);
 

=== modified file 'plugins/expo/CMakeLists.txt'
--- plugins/expo/CMakeLists.txt	2012-05-16 17:40:58 +0000
+++ plugins/expo/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -1,7 +1,4 @@
 find_package (Compiz REQUIRED)
-include (FindOpenGL)
 include (CompizPlugin)
 
-if (OPENGL_GLU_FOUND)
-    compiz_plugin (expo PLUGINDEPS composite opengl LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
+compiz_plugin (expo PLUGINDEPS composite opengl)

=== modified file 'plugins/expo/src/expo.cpp'
--- plugins/expo/src/expo.cpp	2012-02-16 05:20:07 +0000
+++ plugins/expo/src/expo.cpp	2012-05-26 15:11:19 +0000
@@ -4,12 +4,14 @@
  *
  * expo.c
  *
+ * Copyright (c) 2011 Linaro Limited
  * Copyright (c) 2008 Dennis Kasprzyk <[e-mail]>
  * Copyright (c) 2006 Robert Carr <[e-mail]>
  *
  * Authors:
  * Robert Carr <[e-mail]>
  * Dennis Kasprzyk <[e-mail]>
+ * Travis Watkins <[e-mail]>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -25,7 +27,7 @@
 
 #include "expo.h"
 #include <math.h>
-#include <GL/glu.h>
+#include <opengl/opengl.h>
 
 COMPIZ_PLUGIN_20090315 (expo, ExpoPluginVTable);
 
@@ -37,8 +39,8 @@
 
 bool
 ExpoScreen::dndInit (CompAction          *action,
-		     CompAction::State   state,
-		     CompOption::Vector& options)
+                     CompAction::State    state,
+                     CompOption::Vector  &options)
 {
     Window xid = CompOption::getIntOptionNamed (options, "root", 0);
     if (xid != screen->root ())
@@ -57,9 +59,9 @@
 }
 
 bool
-ExpoScreen::dndFini (CompAction          *action,
-		     CompAction::State   state,
-		     CompOption::Vector& options)
+ExpoScreen::dndFini (CompAction         *action,
+                     CompAction::State   state,
+                     CompOption::Vector &options)
 {
     Window xid = CompOption::getIntOptionNamed (options, "root", 0);
     if (xid != screen->root ())
@@ -83,9 +85,9 @@
 }
 
 bool
-ExpoScreen::doExpo (CompAction          *action,
-		    CompAction::State   state,
-		    CompOption::Vector& options)
+ExpoScreen::doExpo (CompAction         *action,
+                    CompAction::State   state,
+                    CompOption::Vector &options)
 {
     Window xid = CompOption::getIntOptionNamed (options, "root", 0);
     if (xid != screen->root ())
@@ -129,9 +131,9 @@
 }
 
 bool
-ExpoScreen::termExpo (CompAction          *action,
-		      CompAction::State   state,
-		      CompOption::Vector& options)
+ExpoScreen::termExpo (CompAction         *action,
+                      CompAction::State   state,
+                      CompOption::Vector &options)
 {
     Window xid = CompOption::getIntOptionNamed (options, "root", 0);
     if (xid && xid != screen->root ())
@@ -165,9 +167,9 @@
 }
 
 bool
-ExpoScreen::exitExpo (CompAction          *action,
-		      CompAction::State   state,
-		      CompOption::Vector& options)
+ExpoScreen::exitExpo (CompAction         *action,
+                      CompAction::State   state,
+                      CompOption::Vector &options)
 {
     Window xid = CompOption::getIntOptionNamed (options, "root", 0);
     if (xid != screen->root ())
@@ -184,9 +186,9 @@
 }
 
 bool
-ExpoScreen::nextVp (CompAction          *action,
-		    CompAction::State   state,
-		    CompOption::Vector& options)
+ExpoScreen::nextVp (CompAction         *action,
+                    CompAction::State   state,
+                    CompOption::Vector &options)
 {
     unsigned int newX, newY;
     Window       xid = CompOption::getIntOptionNamed (options, "root", 0);
@@ -215,9 +217,9 @@
 }
 
 bool
-ExpoScreen::prevVp (CompAction          *action,
-		    CompAction::State   state,
-		    CompOption::Vector& options)
+ExpoScreen::prevVp (CompAction         *action,
+                    CompAction::State   state,
+                    CompOption::Vector &options)
 {
     unsigned int newX, newY;
     Window       xid = CompOption::getIntOptionNamed (options, "root", 0);
@@ -457,8 +459,8 @@
 }
 
 void
-ExpoScreen::paint (CompOutput::ptrList& outputs,
-		   unsigned int         mask)
+ExpoScreen::paint (CompOutput::ptrList &outputs,
+                   unsigned int         mask)
 {
     int width = outputs.front ()->width ();
     int height = outputs.front ()->height ();
@@ -621,15 +623,63 @@
     }
 }
 
+static bool
+unproject (float winx, float winy, float winz,
+           const GLMatrix &modelview,
+           const GLMatrix &projection,
+           const GLint viewport[4],
+           float *objx, float *objy, float *objz)
+{
+    GLMatrix finalMatrix = projection * modelview;
+    float in[4], out[4];
+
+    if (!finalMatrix.invert ())
+	return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = 1.0;
+
+    /* Map x and y from window coordinates */
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+
+    /* Map to range -1 to 1 */
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    for (int i = 0; i < 4; i++)
+    {
+	out[i] = in[0] * finalMatrix[i] +
+	         in[1] * finalMatrix[4  + i] +
+	         in[2] * finalMatrix[8  + i] +
+	         in[3] * finalMatrix[12 + i];
+    }
+
+    if (out[3] == 0.0)
+	return false;
+
+    out[0] /= out[3];
+    out[1] /= out[3];
+    out[2] /= out[3];
+
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+
+    return true;
+}
+
 void
-ExpoScreen::invertTransformedVertex (const GLScreenPaintAttrib& attrib,
-				     const GLMatrix&            transform,
-				     CompOutput                 *output,
-				     int                        vertex[2])
+ExpoScreen::invertTransformedVertex (const GLScreenPaintAttrib &attrib,
+                                     const GLMatrix            &transform,
+                                     CompOutput                *output,
+                                     int                        vertex[2])
 {
     GLMatrix sTransform (transform);
-    GLdouble p1[3], p2[3], v[3], alpha;
-    GLdouble mvm[16], pm[16];
+    float    p1[3], p2[3], v[3], alpha;
     GLint    viewport[4];
     int      i;
 
@@ -637,16 +687,13 @@
     sTransform.toScreenSpace (output, -attrib.zTranslate);
 
     glGetIntegerv (GL_VIEWPORT, viewport);
-    for (i = 0; i < 16; i++)
-    {
-	mvm[i] = sTransform[i];
-	pm[i]  = gScreen->projectionMatrix ()[i];
-    }
 
-    gluUnProject (vertex[0], screen->height () - vertex[1], 0, mvm, pm,
-		  viewport, &p1[0], &p1[1], &p1[2]);
-    gluUnProject (vertex[0], screen->height () - vertex[1], -1.0, mvm, pm,
-		  viewport, &p2[0], &p2[1], &p2[2]);
+    unproject (vertex[0], screen->height () - vertex[1], 0,
+               sTransform, *gScreen->projectionMatrix (), viewport,
+               &p1[0], &p1[1], &p1[2]);
+    unproject (vertex[0], screen->height () - vertex[1], -1.0,
+               sTransform, *gScreen->projectionMatrix (), viewport,
+               &p2[0], &p2[1], &p2[2]);
 
     for (i = 0; i < 3; i++)
 	v[i] = p1[i] - p2[i];
@@ -693,13 +740,15 @@
 }
 
 void
-ExpoScreen::paintWall (const GLScreenPaintAttrib& attrib,
-		       const GLMatrix&            transform,
-		       const CompRegion&          region,
-		       CompOutput                 *output,
-		       unsigned int               mask,
-		       bool                       reflection)
+ExpoScreen::paintWall (const GLScreenPaintAttrib &attrib,
+                       const GLMatrix            &transform,
+                       const CompRegion          &region,
+                       CompOutput                *output,
+                       unsigned int               mask,
+                       bool                       reflection)
 {
+    GLfloat vertexData[12];
+    GLushort colorData[16];
     GLMatrix sTransformW, sTransform (transform);
     int      i, j, vp;
     GLenum   oldFilter = gScreen->textureFilter ();
@@ -720,6 +769,8 @@
     int      glPaintTransformedOutputIndex =
 	gScreen->glPaintTransformedOutputGetCurrentIndex ();
 
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+
     // Make sure that the base glPaintTransformedOutput function is called
     gScreen->glPaintTransformedOutputSetCurrentIndex (MAXSHORT);
 
@@ -812,7 +863,7 @@
     /* zoom out */
     oScale = DEFAULT_Z_CAMERA / (cam[GLVector::z] + DEFAULT_Z_CAMERA);
     sTransform.scale (oScale, oScale, oScale);
-    glNormal3f (0.0, 0.0, -oScale);
+//    glNormal3f (0.0, 0.0, -oScale);
     sTransform.translate (-cam[GLVector::x], -cam[GLVector::y],
 			  -cam[GLVector::z] - DEFAULT_Z_CAMERA);
 
@@ -947,73 +998,169 @@
 	sTransform.translate (0.0, -(sy + gapY), 0.0f);
     }
 
-    glNormal3f (0.0, 0.0, -1.0);
+//    glNormal3f (0.0, 0.0, -1.0);
 
     if (reflection)
     {
 	glEnable (GL_BLEND);
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	glPushMatrix ();
-
 	if (optionGetDeform () != DeformCurve)
 	{
-	    glLoadMatrixf (sTransformW.getMatrix ());
-
-	    glBegin (GL_QUADS);
-	    glColor4f (0.0, 0.0, 0.0, 1.0);
-	    glVertex2f (0.0, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.5);
-	    glVertex2f (0.0, -vpSize.y () * (sy + gapY));
-	    glVertex2f (vpSize.x () * sx * (1.0 + gapX),
-			-vpSize.y () * sy * (1.0 + gapY));
-	    glColor4f (0.0, 0.0, 0.0, 1.0);
-	    glVertex2f (vpSize.x () * sx * (1.0 + gapX), 0.0);
-	    glEnd ();
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = 65535;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = 32768;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = 65535;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = 32768;
+
+	    vertexData[0]  = 0;
+	    vertexData[1]  = 0;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0;
+	    vertexData[4]  = -vpSize.y () * (sy + gapY);
+	    vertexData[5]  = 0;
+	    vertexData[6]  = vpSize.x () * sx * (1.0 + gapX);
+	    vertexData[7]  = 0;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = vpSize.x () * sx * (1.0 + gapX);
+	    vertexData[10] = -vpSize.y () * sy * (1.0 + gapY);
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransformW);
 	}
 	else
 	{
+	    GLMatrix cTransform;
+	    cTransform.translate (0.0, 0.0, -DEFAULT_Z_CAMERA);
+
 	    glCullFace (GL_BACK);
-	    glLoadIdentity ();
-	    glTranslatef (0.0, 0.0, -DEFAULT_Z_CAMERA);
-
-	    glBegin (GL_QUADS);
-	    glColor4f (0.0, 0.0, 0.0, 1.0 * expoCam);
-	    glVertex2f (-0.5, -0.5);
-	    glVertex2f (0.5, -0.5);
-	    glColor4f (0.0, 0.0, 0.0, 0.5 * expoCam);
-	    glVertex2f (0.5, 0.0);
-	    glVertex2f (-0.5, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.5 * expoCam);
-	    glVertex2f (-0.5, 0.0);
-	    glVertex2f (0.5, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.0);
-	    glVertex2f (0.5, 0.5);
-	    glVertex2f (-0.5, 0.5);
-	    glEnd ();
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = (1.0 * expoCam) * 65536;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = (1.0 * expoCam) * 65536;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = (0.5 * expoCam) * 65536;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = (0.5 * expoCam) * 65536;
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = -0.5;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = -0.5;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = 0;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = 0;
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (cTransform);
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = (0.5 * expoCam) * 65536;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = (0.5 * expoCam) * 65536;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = 0;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = 0;
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = 0;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = 0;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = 0.5;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = 0.5;
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (cTransform);
 	}
 	glCullFace (GL_BACK);
 
-	glLoadIdentity ();
-	glTranslatef (0.0, 0.0, -DEFAULT_Z_CAMERA);
-
 	if (optionGetGroundSize () > 0.0)
 	{
-	    glBegin (GL_QUADS);
-	    glColor4usv (optionGetGroundColor1 ());
-	    glVertex2f (-0.5, -0.5);
-	    glVertex2f (0.5, -0.5);
-	    glColor4usv (optionGetGroundColor2 ());
-	    glVertex2f (0.5, -0.5 + optionGetGroundSize ());
-	    glVertex2f (-0.5, -0.5 + optionGetGroundSize ());
-	    glEnd ();
+	    GLMatrix gTransform;
+	    gTransform.translate (0.0, 0.0, -DEFAULT_Z_CAMERA);
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = -0.5;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = -0.5;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = -0.5 + optionGetGroundSize ();
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = -0.5 + optionGetGroundSize ();
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (1, optionGetGroundColor1 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor1 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor2 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor2 ());
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (gTransform);
 	}
-
-	glColor4usv (defaultColor);
-
 	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 	glDisable (GL_BLEND);
-	glPopMatrix ();
     }
 
     expoActive = false;
@@ -1025,11 +1172,11 @@
 }
 
 bool
-ExpoScreen::glPaintOutput (const GLScreenPaintAttrib& attrib,
-			   const GLMatrix&            transform,
-			   const CompRegion&          region,
-			   CompOutput                 *output,
-			   unsigned int               mask)
+ExpoScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
+                           const GLMatrix            &transform,
+                           const CompRegion          &region,
+                           CompOutput                *output,
+                           unsigned int               mask)
 {
     if (expoCam > 0.0)
 	mask |= PAINT_SCREEN_TRANSFORMED_MASK | PAINT_SCREEN_CLEAR_MASK;
@@ -1038,11 +1185,11 @@
 }
 
 void
-ExpoScreen::glPaintTransformedOutput (const GLScreenPaintAttrib& attrib,
-				      const GLMatrix&            transform,
-				      const CompRegion&          region,
-				      CompOutput                 *output,
-				      unsigned int               mask)
+ExpoScreen::glPaintTransformedOutput (const GLScreenPaintAttrib &attrib,
+                                      const GLMatrix            &transform,
+                                      const CompRegion          &region,
+                                      CompOutput                *output,
+                                      unsigned int               mask)
 {
     expoActive = false;
 
@@ -1073,23 +1220,23 @@
 }
 
 bool
-ExpoWindow::glDraw (const GLMatrix&     transform,
-		    GLFragment::Attrib& fragment,
-		    const CompRegion&   region,
-		    unsigned int        mask)
+ExpoWindow::glDraw (const GLMatrix            &transform,
+                    const GLWindowPaintAttrib &attrib,
+                    const CompRegion          &region,
+                    unsigned int               mask)
 {
     if (eScreen->expoCam == 0.0f)
-	return gWindow->glDraw (transform, fragment, region, mask);
+	return gWindow->glDraw (transform, attrib, region, mask);
 
-    GLFragment::Attrib fA (fragment);
-    int                expoAnimation;
+    GLWindowPaintAttrib eAttrib (attrib);
+    int                 expoAnimation;
 
     expoAnimation = eScreen->optionGetExpoAnimation ();
 
     if (eScreen->expoActive)
     {
 	if (expoAnimation != ExpoScreen::ExpoAnimationZoom)
-	    fA.setOpacity (fragment.getOpacity () * eScreen->expoCam);
+	    eAttrib.opacity = attrib.opacity * eScreen->expoCam;
 
 	if (window->wmType () & CompWindowTypeDockMask &&
 	    eScreen->optionGetHideDocks ())
@@ -1097,44 +1244,45 @@
 	    if (expoAnimation == ExpoScreen::ExpoAnimationZoom &&
 		eScreen->paintingVp == eScreen->selectedVp)
 	    {
-		fA.setOpacity (fragment.getOpacity () *
-			       (1 - sigmoidProgress (eScreen->expoCam)));
+		eAttrib.opacity = attrib.opacity *
+		                      (1 - sigmoidProgress (eScreen->expoCam));
 	    }
 	    else
 	    {
-		fA.setOpacity (0);
+		eAttrib.opacity = 0;
 	    }
 	}
 
-	fA.setBrightness (fragment.getBrightness () * eScreen->vpBrightness);
-	fA.setSaturation (fragment.getSaturation () * eScreen->vpSaturation);
+	eAttrib.brightness = attrib.brightness * eScreen->vpBrightness;
+	eAttrib.saturation = attrib.saturation * eScreen->vpSaturation;
     }
     else
     {
 	if (expoAnimation == ExpoScreen::ExpoAnimationZoom)
-	    fA.setBrightness (0);
+	    eAttrib.brightness = 0;
 	else
-	    fA.setBrightness (fragment.getBrightness () *
-			      (1 - sigmoidProgress (eScreen->expoCam)));
+	    eAttrib.brightness = attrib.brightness *
+	                              (1 - sigmoidProgress (eScreen->expoCam));
     }
 
-    return gWindow->glDraw (transform, fA, region, mask);
+    return gWindow->glDraw (transform, eAttrib, region, mask);
 }
 
 #define EXPO_GRID_SIZE 100
 
 void
-ExpoWindow::glAddGeometry (const GLTexture::MatrixList& matrices,
-			   const CompRegion&            region,
-			   const CompRegion&            clip,
-			   unsigned int                 maxGridWidth,
-			   unsigned int                 maxGridHeight)
+ExpoWindow::glAddGeometry (const GLTexture::MatrixList &matrices,
+                           const CompRegion            &region,
+                           const CompRegion            &clip,
+                           unsigned int                 maxGridWidth,
+                           unsigned int                 maxGridHeight)
 {
     if (eScreen->expoCam > 0.0        &&
 	screen->desktopWindowCount () &&
 	eScreen->optionGetDeform () == ExpoScreen::DeformCurve)
     {
-	int         i, oldVCount = gWindow->geometry ().vCount;
+/* XXX: Curve mode not ported right now */
+/*	int         i, oldVCount = gWindow->geometry ().vCount;
 	GLfloat     *v;
 	CompPoint   offset;
 	float       lastX, lastZ = 0.0;
@@ -1179,7 +1327,7 @@
 	    lastZ = v[2];
 
 	    v += gWindow->geometry ().vertexStride;
-	}
+	} */
     }
     else
     {
@@ -1188,16 +1336,18 @@
 }
 
 void
-ExpoWindow::glDrawTexture (GLTexture           *texture,
-			   GLFragment::Attrib& attrib,
-			   unsigned int        mask)
+ExpoWindow::glDrawTexture (GLTexture                 *texture,
+                           const GLMatrix            &transform,
+                           const GLWindowPaintAttrib &attrib,
+                           unsigned int               mask)
 {
     if (eScreen->expoCam > 0.0                                 &&
 	eScreen->optionGetDeform () == ExpoScreen::DeformCurve &&
 	eScreen->gScreen->lighting ()                          &&
 	screen->desktopWindowCount ())
     {
-	unsigned int i, idx, vCount;
+/* XXX: Curve mode not ported right now */
+/*	unsigned int i, idx, vCount;
 	CompPoint    offset;
 	float        x;
 	GLfloat      *v;
@@ -1244,21 +1394,21 @@
 
 	glDisable (GL_NORMALIZE);
 	glDisableClientState (GL_NORMAL_ARRAY);
-	glNormal3f (0.0, 0.0, -1.0);
+	glNormal3f (0.0, 0.0, -1.0); */
     }
     else
     {
-	glEnable (GL_NORMALIZE);
-	gWindow->glDrawTexture (texture, attrib, mask);
-	glDisable (GL_NORMALIZE);
+//	glEnable (GL_NORMALIZE);
+	gWindow->glDrawTexture (texture, transform, attrib, mask);
+//	glDisable (GL_NORMALIZE);
     }
 }
 
 bool
-ExpoWindow::glPaint (const GLWindowPaintAttrib& attrib,
-		     const GLMatrix&            transform,
-		     const CompRegion&          region,
-		     unsigned int               mask)
+ExpoWindow::glPaint (const GLWindowPaintAttrib &attrib,
+                     const GLMatrix            &transform,
+                     const CompRegion          &region,
+                     unsigned int               mask)
 {
     if (eScreen->expoActive)
     {
@@ -1286,7 +1436,7 @@
 	{
 	    if (zoomAnim && eScreen->paintingVp == eScreen->selectedVp)
 		opacity = attrib.opacity *
-			  (1 - sigmoidProgress (eScreen->expoCam));
+		                      (1 - sigmoidProgress (eScreen->expoCam));
 	    else
 		opacity = 0;
 	}
@@ -1300,7 +1450,7 @@
 
 bool
 ExpoWindow::damageRect (bool            initial,
-			const CompRect& rect)
+                        const CompRect &rect)
 {
     if (eScreen->expoCam > 0.0f)
 	eScreen->cScreen->damageScreen ();

=== modified file 'plugins/expo/src/expo.h'
--- plugins/expo/src/expo.h	2011-09-20 14:38:27 +0000
+++ plugins/expo/src/expo.h	2012-05-26 15:11:19 +0000
@@ -48,18 +48,18 @@
 	void donePaint ();
 
 	bool glPaintOutput (const GLScreenPaintAttrib&, const GLMatrix&,
-			    const CompRegion&, CompOutput *, unsigned int);
+	                    const CompRegion&, CompOutput *, unsigned int);
 	void glPaintTransformedOutput (const GLScreenPaintAttrib&,
-				       const GLMatrix&, const CompRegion&,
-				       CompOutput *, unsigned int);
+	                               const GLMatrix&, const CompRegion&,
+	                               CompOutput*, unsigned int);
 
-	bool dndInit (CompAction *, CompAction::State, CompOption::Vector&);
-	bool dndFini (CompAction *, CompAction::State, CompOption::Vector&);
-	bool doExpo (CompAction *, CompAction::State, CompOption::Vector&);
-	bool exitExpo (CompAction *, CompAction::State, CompOption::Vector&);
-	bool termExpo (CompAction *, CompAction::State, CompOption::Vector&);
-	bool nextVp (CompAction *, CompAction::State, CompOption::Vector&);
-	bool prevVp (CompAction *, CompAction::State, CompOption::Vector&);
+	bool dndInit (CompAction*, CompAction::State, CompOption::Vector&);
+	bool dndFini (CompAction*, CompAction::State, CompOption::Vector&);
+	bool doExpo (CompAction*, CompAction::State, CompOption::Vector&);
+	bool exitExpo (CompAction*, CompAction::State, CompOption::Vector&);
+	bool termExpo (CompAction*, CompAction::State, CompOption::Vector&);
+	bool nextVp (CompAction*, CompAction::State, CompOption::Vector&);
+	bool prevVp (CompAction*, CompAction::State, CompOption::Vector&);
 
 	typedef enum {
 	    DnDNone,
@@ -80,7 +80,7 @@
 	bool  expoActive;
 	bool  expoMode;
 
-	DnDState   dndState;
+	DnDState    dndState;
 	CompWindow *dndWindow;
 
 	CompPoint prevCursor;
@@ -118,9 +118,9 @@
 	void updateWraps (bool);
 
 	void invertTransformedVertex (const GLScreenPaintAttrib&,
-				      const GLMatrix&, CompOutput *, int[2]);
+	                              const GLMatrix&, CompOutput *, int[2]);
 	void paintWall (const GLScreenPaintAttrib&, const GLMatrix&,
-			const CompRegion&, CompOutput *, unsigned int, bool);
+	                const CompRegion&, CompOutput *, unsigned int, bool);
 
 	KeyCode leftKey;
 	KeyCode rightKey;
@@ -138,15 +138,15 @@
 
 	bool damageRect (bool, const CompRect&);
 
-	bool glDraw (const GLMatrix&, GLFragment::Attrib&,
-		     const CompRegion&, unsigned int);
+	bool glDraw (const GLMatrix&, const GLWindowPaintAttrib&,
+	             const CompRegion&, unsigned int);
 	bool glPaint (const GLWindowPaintAttrib&, const GLMatrix&,
-		      const CompRegion&, unsigned int);
+	              const CompRegion&, unsigned int);
 	void glAddGeometry (const GLTexture::MatrixList&,
-			    const CompRegion&, const CompRegion&,
-			    unsigned int, unsigned int);
-	void glDrawTexture (GLTexture *, GLFragment::Attrib& attrib,
-			    unsigned int);
+	                    const CompRegion&, const CompRegion&,
+	                    unsigned int, unsigned int);
+	void glDrawTexture (GLTexture*, const GLMatrix&,
+	                    const GLWindowPaintAttrib&, unsigned int);
 
 	CompWindow      *window;
 	CompositeWindow *cWindow;

=== modified file 'plugins/ezoom/src/ezoom.cpp'
--- plugins/ezoom/src/ezoom.cpp	2012-05-18 06:52:20 +0000
+++ plugins/ezoom/src/ezoom.cpp	2012-05-26 15:11:19 +0000
@@ -378,13 +378,16 @@
 /* Draws a box from the screen coordinates inx1,iny1 to inx2,iny2 */
 void
 EZoomScreen::drawBox (const GLMatrix &transform,
-		     CompOutput          *output,
-		     CompRect             box)
+                      CompOutput     *output,
+                      CompRect        box)
 {
-    GLMatrix zTransform = transform;
-    int           x1,x2,y1,y2;
-    int		  inx1, inx2, iny1, iny2;
-    int	          out = output->id ();
+    GLMatrix zTransform (transform);
+    int      x1, x2, y1, y2;
+    int      inx1, inx2, iny1, iny2;
+    int      out = output->id ();
+    GLushort colorData[4];
+    GLfloat  vertexData[12];
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
 
     zTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
     convertToZoomed (out, box.x1 (), box.y1 (), &inx1, &iny1);
@@ -394,23 +397,61 @@
     y1 = MIN (iny1, iny2);
     x2 = MAX (inx1, inx2);
     y2 = MAX (iny1, iny2);
-    glPushMatrix ();
-    glLoadMatrixf (zTransform.getMatrix ());
-    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->begin (GL_TRIANGLE_STRIP);
+
+    colorData[0] = 0x2fff;
+    colorData[1] = 0x2fff;
+    colorData[2] = 0x2fff;
+    colorData[3] = 0x4fff;
+
+    streamingBuffer->addColors (1, colorData);
+
+    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;
+
+    streamingBuffer->addVertices (4, vertexData);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (zTransform);
+
+
+    streamingBuffer->begin (GL_LINE_LOOP);
+
+    colorData[0] = 0x2fff;
+    colorData[1] = 0x2fff;
+    colorData[2] = 0x4fff;
+    colorData[3] = 0x9fff;
+
+    streamingBuffer->addColors (1, colorData);
+
+    vertexData[0]  = x1;
+    vertexData[1]  = y1;
+    vertexData[2]  = 0.0f;
+    vertexData[3]  = x2;
+    vertexData[4]  = y1;
+    vertexData[5]  = 0.0f;
+    vertexData[6]  = x2;
+    vertexData[7]  = y2;
+    vertexData[8]  = 0.0f;
+    vertexData[9]  = x1;
+    vertexData[10] = y2;
+    vertexData[11] = 0.0f;
+
+    streamingBuffer->addVertices (4, vertexData);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (zTransform);
 }
 /* Apply the zoom if we are grabbed.
  * Make sure to use the correct filter.
@@ -1050,22 +1091,25 @@
 
 /* Translate into place and draw the scaled cursor.  */
 void
-EZoomScreen::drawCursor (CompOutput          *output,
-	    		const GLMatrix      &transform)
+EZoomScreen::drawCursor (CompOutput     *output,
+                         const GLMatrix &transform)
 {
-    int         out = output->id ();
+    int out = output->id ();
 
     if (cursor.isSet)
     {
-	GLMatrix      sTransform = transform;
-	float	      scaleFactor;
-	int           ax, ay, x, y;
+	GLMatrix        sTransform (transform);
+	float           scaleFactor;
+	int             ax, ay, x, y;
+	GLfloat         textureData[8];
+	GLfloat         vertexData[12];
+	GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
 
 	/*
 	 * XXX: expo knows how to handle mouse when zoomed, so we back off
 	 * when expo is active.
 	 */
-	if (screen->grabExist ( "expo"))
+	if (screen->grabExist ("expo"))
 	{
 	    cursorZoomInactive ();
 	    return;
@@ -1073,63 +1117,77 @@
 
 	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 	convertToZoomed (out, mouse.x (), mouse.y (), &ax, &ay);
-        glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-	glTranslatef ((float) ax, (float) ay, 0.0f);
+	sTransform.translate ((float) ax, (float) ay, 0.0f);
+
 	if (optionGetScaleMouseDynamic ())
 	    scaleFactor = 1.0f / zooms.at (out).currentZoom;
 	else
 	    scaleFactor = 1.0f / optionGetScaleMouseStatic ();
-	glScalef (scaleFactor,
-		  scaleFactor,
-		  1.0f);
+
+	sTransform.scale (scaleFactor, scaleFactor, 1.0f);
 	x = -cursor.hotX;
 	y = -cursor.hotY;
 
-	glEnable (GL_BLEND);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor.texture);
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
-
-	glBegin (GL_QUADS);
-	glTexCoord2d (0, 0);
-	glVertex2f (x, y);
-	glTexCoord2d (0, cursor.height);
-	glVertex2f (x, y + cursor.height);
-	glTexCoord2d (cursor.width, cursor.height);
-	glVertex2f (x + cursor.width, y + cursor.height);
-	glTexCoord2d (cursor.width, 0);
-	glVertex2f (x + cursor.width, y);
-	glEnd ();
-	glDisable (GL_BLEND);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
-	glDisable (GL_TEXTURE_RECTANGLE_ARB);
-	glPopMatrix ();
+	glBindTexture (GL_TEXTURE_2D, cursor.texture);
+
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	vertexData[0]  = x;
+	vertexData[1]  = y;
+	vertexData[2]  = 0.0f;
+	vertexData[3]  = x;
+	vertexData[4]  = y + cursor.height;
+	vertexData[5]  = 0.0f;
+	vertexData[6]  = x + cursor.width;
+	vertexData[7]  = y;
+	vertexData[8]  = 0.0f;
+	vertexData[9]  = x + cursor.width;
+	vertexData[10] = y + cursor.height;
+	vertexData[11] = 0.0f;
+
+	streamingBuffer->addVertices (4, vertexData);
+
+	textureData[0] = 0;
+	textureData[1] = 0;
+	textureData[2] = 0;
+	textureData[3] = cursor.height;
+	textureData[4] = cursor.width;
+	textureData[5] = 0;
+	textureData[6] = cursor.width;
+	textureData[7] = cursor.height;
+
+	streamingBuffer->addTexCoords (1, 4, textureData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+
+	glBindTexture (GL_TEXTURE_2D, 0);
     }
 }
 
 /* Create (if necessary) a texture to store the cursor,
  * fetch the cursor with XFixes. Store it.  */
 void
-EZoomScreen::updateCursor (CursorTexture * cursor)
+EZoomScreen::updateCursor (CursorTexture *cursor)
 {
     unsigned char *pixels;
-    int           i;
+    int            i;
     Display       *dpy = screen->dpy ();
 
     if (!cursor->isSet)
     {
 	cursor->isSet = true;
 	cursor->screen = screen;
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
+
+	glEnable (GL_TEXTURE_2D);
 	glGenTextures (1, &cursor->texture);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor->texture);
+	glBindTexture (GL_TEXTURE_2D, cursor->texture);
 
-	glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-			 GL_TEXTURE_WRAP_S, GL_CLAMP);
-	glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-			 GL_TEXTURE_WRAP_T, GL_CLAMP);
-    } else {
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    }
+    else {
+	glEnable (GL_TEXTURE_2D);
     }
 
     XFixesCursorImage *ci = XFixesGetCursorImage (dpy);
@@ -1185,11 +1243,11 @@
 	compLogMessage ("ezoom", CompLogLevelWarn, "unable to get system cursor image!");
     }
 
-    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor->texture);
-    glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, cursor->width,
+    glBindTexture (GL_TEXTURE_2D, cursor->texture);
+    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, cursor->width,
 		  cursor->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
-    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
-    glDisable (GL_TEXTURE_RECTANGLE_ARB);
+    glBindTexture (GL_TEXTURE_2D, 0);
+    glDisable (GL_TEXTURE_2D);
 	
     free (pixels);
 }

=== modified file 'plugins/grid/src/grid.cpp'
--- plugins/grid/src/grid.cpp	2012-01-26 10:02:16 +0000
+++ plugins/grid/src/grid.cpp	2012-05-26 15:11:19 +0000
@@ -431,100 +431,155 @@
 {
     CompRect rect;
     GLMatrix sTransform (transform);
-	std::vector<Animation>::iterator iter;
+    std::vector<Animation>::iterator iter;
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+    GLfloat         vertexData[12];
+    GLushort        colorData[4];
+    GLushort       *color;
+    GLboolean       isBlendingEnabled;
 
     getPaintRectangle (rect);
 
-	for (unsigned int i = 0; i < animations.size (); i++)
-		setCurrentRect (animations.at (i));
-
-    glPushMatrix ();
+    for (unsigned int i = 0; i < animations.size (); i++)
+	setCurrentRect (animations.at (i));
 
     sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
-    glLoadMatrixf (sTransform.getMatrix ());
-
-    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
+    glGetBooleanv (GL_BLEND, &isBlendingEnabled);
     glEnable (GL_BLEND);
 
-	for (iter = animations.begin (); iter != animations.end () && animating; iter++)
-	{
-		Animation& anim = *iter;
-		float alpha = ((float) optionGetFillColorAlpha () / 65535.0f) * anim.opacity;
-
-		/* fill rectangle */
-		glColor4f (((float) optionGetFillColorRed () / 65535.0f) * alpha,
-			   ((float) optionGetFillColorGreen () / 65535.0f) * alpha,
-			   ((float) optionGetFillColorBlue () / 65535.0f) * alpha,
-			   alpha);
-
-		/* fill rectangle */
-		glRecti (anim.currentRect.x1 (), anim.currentRect.y2 (),
-				 anim.currentRect.x2 (), anim.currentRect.y1 ());
-
-		/* Set outline rect smaller to avoid damage issues */
-		anim.currentRect.setGeometry (anim.currentRect.x () + 1,
-					      anim.currentRect.y () + 1,
-					      anim.currentRect.width () - 2,
-					      anim.currentRect.height () - 2);
-
-		alpha = (float) (optionGetOutlineColorAlpha () / 65535.0f) * anim.opacity;
-
-		/* draw outline */
-		glColor4f (((float) optionGetOutlineColorRed () / 65535.0f) * alpha,
-			   ((float) optionGetOutlineColorGreen () / 65535.0f) * alpha,
-			   ((float) optionGetOutlineColorBlue () / 65535.0f) * alpha,
-			   alpha);
-
-		glLineWidth (2.0);
-
-		glBegin (GL_LINE_LOOP);
-		glVertex2i (anim.currentRect.x1 (),	anim.currentRect.y1 ());
-		glVertex2i (anim.currentRect.x2 (),	anim.currentRect.y1 ());
-		glVertex2i (anim.currentRect.x2 (),	anim.currentRect.y2 ());
-		glVertex2i (anim.currentRect.x1 (),	anim.currentRect.y2 ());
-		glEnd ();
-	}
-
-	if (!animating)
-	{
-		/* fill rectangle */
-		float alpha = (float) optionGetFillColorAlpha () / 65535.0f;
-
-		/* fill rectangle */
-		glColor4f (((float) optionGetFillColorRed () / 65535.0f) * alpha,
-			   ((float) optionGetFillColorGreen () / 65535.0f) * alpha,
-			   ((float) optionGetFillColorBlue () / 65535.0f) * alpha,
-			   alpha);
-		glRecti (rect.x1 (), rect.y2 (), rect.x2 (), rect.y1 ());
-
-		/* Set outline rect smaller to avoid damage issues */
-		rect.setGeometry (rect.x () + 1, rect.y () + 1,
-				  rect.width () - 2, rect.height () - 2);
-
-		/* draw outline */
-		alpha = (float) optionGetOutlineColorAlpha () / 65535.0f;
-
-		/* draw outline */
-		glColor4f (((float) optionGetOutlineColorRed () / 65535.0f) * alpha,
-			   ((float) optionGetOutlineColorGreen () / 65535.0f) * alpha,
-			   ((float) optionGetOutlineColorBlue () / 65535.0f) * alpha,
-			   alpha);
-
-		glLineWidth (2.0);
-		glBegin (GL_LINE_LOOP);
-		glVertex2i (rect.x1 (), rect.y1 ());
-		glVertex2i (rect.x2 (), rect.y1 ());
-		glVertex2i (rect.x2 (), rect.y2 ());
-		glVertex2i (rect.x1 (), rect.y2 ());
-		glEnd ();
-	}
-
-    /* clean up */
-    glColor4usv (defaultColor);
-    glDisable (GL_BLEND);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-    glPopMatrix ();
+    for (iter = animations.begin (); iter != animations.end () && animating; iter++)
+    {
+	Animation& anim = *iter;
+	float alpha = ((float) optionGetFillColorAlpha () / 65535.0f) * anim.opacity;
+	color = optionGetFillColor ();
+
+	colorData[0] = alpha * color[0];
+	colorData[1] = alpha * color[1];
+	colorData[2] = alpha * color[2];
+	colorData[3] = alpha * 65535.0f;
+
+	vertexData[0]  = anim.currentRect.x1 ();
+	vertexData[1]  = anim.currentRect.y1 ();
+	vertexData[2]  = 0.0f;
+	vertexData[3]  = anim.currentRect.x1 ();
+	vertexData[4]  = anim.currentRect.y2 ();
+	vertexData[5]  = 0.0f;
+	vertexData[6]  = anim.currentRect.x2 ();
+	vertexData[7]  = anim.currentRect.y1 ();
+	vertexData[8]  = 0.0f;
+	vertexData[9]  = anim.currentRect.x2 ();
+	vertexData[10] = anim.currentRect.y2 ();
+	vertexData[11] = 0.0f;
+
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+	streamingBuffer->addColors (1, colorData);
+	streamingBuffer->addVertices (4, vertexData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+
+	/* Set outline rect smaller to avoid damage issues */
+	anim.currentRect.setGeometry (anim.currentRect.x () + 1,
+				      anim.currentRect.y () + 1,
+				      anim.currentRect.width () - 2,
+				      anim.currentRect.height () - 2);
+
+	/* draw outline */
+	alpha = ((float) optionGetOutlineColorAlpha () / 65535.0f) * anim.opacity;
+	color = optionGetOutlineColor ();
+
+	colorData[0] = alpha * color[0];
+	colorData[1] = alpha * color[1];
+	colorData[2] = alpha * color[2];
+	colorData[3] = alpha * 65535.0f;
+
+	vertexData[0]  = anim.currentRect.x1 ();
+	vertexData[1]  = anim.currentRect.y1 ();
+	vertexData[3]  = anim.currentRect.x1 ();
+	vertexData[4]  = anim.currentRect.y2 ();
+	vertexData[6]  = anim.currentRect.x2 ();
+	vertexData[7]  = anim.currentRect.y2 ();
+	vertexData[9]  = anim.currentRect.x2 ();
+	vertexData[10] = anim.currentRect.y1 ();
+
+	glLineWidth (2.0);
+
+	streamingBuffer->begin (GL_LINE_LOOP);
+	streamingBuffer->addColors (1, colorData);
+	streamingBuffer->addVertices (4, vertexData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+    }
+
+    if (!animating)
+    {
+	/* draw filled rectangle */
+	float alpha = (float) optionGetFillColorAlpha () / 65535.0f;
+	color = optionGetFillColor ();
+
+	colorData[0] = alpha * color[0];
+	colorData[1] = alpha * color[1];
+	colorData[2] = alpha * color[2];
+	colorData[3] = alpha * 65535.0f;
+
+	vertexData[0]  = rect.x1 ();
+	vertexData[1]  = rect.y1 ();
+	vertexData[2]  = 0.0f;
+	vertexData[3]  = rect.x1 ();
+	vertexData[4]  = rect.y2 ();
+	vertexData[5]  = 0.0f;
+	vertexData[6]  = rect.x2 ();
+	vertexData[7]  = rect.y1 ();
+	vertexData[8]  = 0.0f;
+	vertexData[9]  = rect.x2 ();
+	vertexData[10] = rect.y2 ();
+	vertexData[11] = 0.0f;
+
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+	streamingBuffer->addColors (1, colorData);
+	streamingBuffer->addVertices (4, vertexData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+
+	/* Set outline rect smaller to avoid damage issues */
+	rect.setGeometry (rect.x () + 1,
+			  rect.y () + 1,
+			  rect.width () - 2,
+			  rect.height () - 2);
+
+	/* draw outline */
+	alpha = (float) optionGetOutlineColorAlpha () / 65535.0f;
+	color = optionGetOutlineColor ();
+
+	colorData[0] = alpha * color[0];
+	colorData[1] = alpha * color[1];
+	colorData[2] = alpha * color[2];
+	colorData[3] = alpha * 65535.0f;
+
+	vertexData[0]  = rect.x1 ();
+	vertexData[1]  = rect.y1 ();
+	vertexData[3]  = rect.x1 ();
+	vertexData[4]  = rect.y2 ();
+	vertexData[6]  = rect.x2 ();
+	vertexData[7]  = rect.y2 ();
+	vertexData[9]  = rect.x2 ();
+	vertexData[10] = rect.y1 ();
+
+	glLineWidth (2.0);
+
+	streamingBuffer->begin (GL_LINE_LOOP);
+	streamingBuffer->addColors (1, colorData);
+	streamingBuffer->addVertices (4, vertexData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+    }
+
+    if (!isBlendingEnabled)
+	glDisable (GL_BLEND);
 }
 
 bool

=== modified file 'plugins/imgsvg/src/imgsvg.cpp'
--- plugins/imgsvg/src/imgsvg.cpp	2012-01-18 16:26:45 +0000
+++ plugins/imgsvg/src/imgsvg.cpp	2012-05-26 15:11:19 +0000
@@ -220,12 +220,12 @@
 }
 
 bool
-SvgWindow::glDraw (const GLMatrix     &transform,
-		   GLFragment::Attrib &fragment,
-		   const CompRegion   &region,
-		   unsigned int       mask)
+SvgWindow::glDraw (const GLMatrix            &transform,
+		   const GLWindowPaintAttrib &attrib,
+		   const CompRegion          &region,
+		   unsigned int              mask)
 {
-    bool status = gWindow->glDraw (transform, fragment, region, mask);
+    bool status = gWindow->glDraw (transform, attrib, region, mask);
 
     if (!status)
 	return status;
@@ -251,13 +251,15 @@
 	{
 	    matrix[0] = context->texture[0].matrices[i];
 
-	    gWindow->geometry ().reset ();
+	    gWindow->vertexBuffer ()->begin ();
 	    gWindow->glAddGeometry (matrix, context->box, reg);
+	    gWindow->vertexBuffer ()->end ();
 
 	    if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
 		mask |= PAINT_WINDOW_BLEND_MASK;
 
-	    gWindow->glDrawTexture (context->texture[0].textures[i], fragment, mask);
+	    gWindow->glDrawTexture (context->texture[0].textures[i], transform,
+	                            attrib, mask);
 
 	    if (rect.width () > 0 && rect.height () > 0)
 	    {
@@ -321,11 +323,12 @@
 		    saveFilter = gScreen->filter (SCREEN_TRANS_FILTER);
 		    gScreen->setFilter (SCREEN_TRANS_FILTER, GLTexture::Good);
 
-		    gWindow->geometry ().reset ();
+		    gWindow->vertexBuffer ()->begin ();
 		    gWindow->glAddGeometry (matrix, r, reg);
+		    gWindow->vertexBuffer ()->end ();
 
 		    gWindow->glDrawTexture (context->texture[1].textures[j],
-					    fragment, mask);
+					    transform, attrib, mask);
 
 		    gScreen->setFilter (SCREEN_TRANS_FILTER, saveFilter);
 		}

=== modified file 'plugins/imgsvg/src/imgsvg.h'
--- plugins/imgsvg/src/imgsvg.h	2012-01-18 16:26:45 +0000
+++ plugins/imgsvg/src/imgsvg.h	2012-05-26 15:11:19 +0000
@@ -76,7 +76,8 @@
 	SvgWindow (CompWindow *window);
 	~SvgWindow ();
 
-	bool glDraw (const GLMatrix &transform, GLFragment::Attrib &fragment,
+	bool glDraw (const GLMatrix &transform,
+		     const GLWindowPaintAttrib &attrib,
 		     const CompRegion &region, unsigned int mask);
 	void moveNotify (int dx, int dy, bool immediate);
 	void resizeNotify (int dx, int dy, int dwidth, int dheight);

=== modified file 'plugins/kdecompat/src/kdecompat.cpp'
--- plugins/kdecompat/src/kdecompat.cpp	2011-02-01 12:17:13 +0000
+++ plugins/kdecompat/src/kdecompat.cpp	2012-05-26 15:11:19 +0000
@@ -204,7 +204,6 @@
 
     if (mSlideData && mSlideData->remaining)
     {
-	GLFragment::Attrib fragment (gWindow->paintAttrib ());
 	GLMatrix           wTransform = transform;
 	SlideData          *data = mSlideData;
 	float              xTranslate = 0, yTranslate = 0, remainder;
@@ -241,26 +240,20 @@
 	status = gWindow->glPaint (attrib, transform, region, mask |
 				   PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
 
-	if (window->alpha () || fragment.getOpacity () != OPAQUE)
+	if (window->alpha () || attrib.opacity != OPAQUE)
 	    mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
 
 	wTransform.translate (xTranslate, yTranslate, 0.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.getMatrix ());
-
-	glPushAttrib (GL_SCISSOR_BIT);
 	glEnable (GL_SCISSOR_TEST);
 
 	glScissor (clipBox.x1 (), screen->height () - clipBox.y2 (),
 		   clipBox.width (), clipBox.height ());
 
-	status = gWindow->glDraw (wTransform, fragment, region,
+	status = gWindow->glDraw (wTransform, attrib, region,
 			 mask | PAINT_WINDOW_TRANSFORMED_MASK);
 
 	glDisable (GL_SCISSOR_TEST);
-	glPopAttrib ();
-	glPopMatrix ();
     }
 
     foreach (const Thumb& thumb, mPreviews)
@@ -329,20 +322,17 @@
 		matrices[0].x0 -= (tw->x () * icon->matrix ().xx);
 		matrices[0].y0 -= (tw->y () * icon->matrix ().yy);
 
-		gtw->geometry ().reset ();
+		gtw->vertexBuffer ()->begin ();
 		gtw->glAddGeometry (matrices, tw->geometry (), infiniteRegion);
-
-		if (!gtw->geometry ().vertices)
-		    icon = NULL;
+		gtw->vertexBuffer ()->end ();
 	    }
 	}
 
 	if (!gtw->textures ().empty () || icon)
 	{
-	    GLFragment::Attrib fragment (attrib);
 	    GLMatrix           wTransform (transform);
 
-	    if (tw->alpha () || fragment.getOpacity () != OPAQUE)
+	    if (tw->alpha () || attrib.opacity != OPAQUE)
 		paintMask |= PAINT_WINDOW_TRANSLUCENT_MASK;
 
 	    wTransform.translate (tw->x (), tw->y (), 0.0f);
@@ -351,16 +341,11 @@
 				  yTranslate / yScale - tw->y (),
 				  0.0f);
 
-	    glPushMatrix ();
-	    glLoadMatrixf (wTransform.getMatrix ());
-
 	    if (!gtw->textures ().empty ())
-		gtw->glDraw (wTransform, fragment,
+		gtw->glDraw (wTransform, attrib,
 				 infiniteRegion, paintMask);
 	    else if (icon)
-		gtw->glDrawTexture (icon, fragment, paintMask);
-
-	    glPopMatrix ();
+		gtw->glDrawTexture (icon, wTransform, attrib, paintMask);
 	}
     }
     

=== modified file 'plugins/neg/src/neg.cpp'
--- plugins/neg/src/neg.cpp	2011-05-18 01:06:37 +0000
+++ plugins/neg/src/neg.cpp	2012-05-26 15:11:19 +0000
@@ -22,7 +22,12 @@
 
 #include "neg.h"
 
-using namespace GLFragment;
+static std::string fragment_function = "                 \n\
+void neg_fragment () {                                   \n\
+    vec3 color = vec3(1.0, 1.0, 1.0) - gl_FragColor.rgb; \n\
+    gl_FragColor = vec4(color, gl_FragColor.a);          \n\
+}                                                        \n\
+";
 
 COMPIZ_PLUGIN_20090315 (neg, NegPluginVTable);
 
@@ -74,65 +79,12 @@
     return true;
 }
 
-int
-NegScreen::getFragmentFunction (GLTexture *texture,
-				bool      alpha)
-{
-    int handle = 0;
-
-    if (alpha && negAlphaFunction)
-	handle = negAlphaFunction;
-    else if (!alpha && negFunction)
-	handle = negFunction;
-
-    if (!handle)
-    {
-	FunctionData data;
-	int          target;
-
-	if (alpha)
-	    data.addTempHeaderOp ("neg");
-
-	if (texture->target () == GL_TEXTURE_2D)
-	    target = COMP_FETCH_TARGET_2D;
-	else
-	    target = COMP_FETCH_TARGET_RECT;
-
-	data.addFetchOp ("output", NULL, target);
-
-	if (alpha)
-	{
-	    data.addDataOp ("RCP neg.a, output.a;");
-	    data.addDataOp ("MAD output.rgb, -neg.a, output, 1.0;");
-	}
-	else
-	    data.addDataOp ("SUB output.rgb, 1.0, output;");
-
-	if (alpha)
-	    data.addDataOp ("MUL output.rgb, output.a, output;");
-
-	data.addColorOp ("output", "output");
-
-	if (!data.status ())
-	    return 0;
-
-	handle = data.createFragmentFunction ("neg");
-
-	if (alpha)
-	    negAlphaFunction = handle;
-	else
-	    negFunction = handle;
-    }
-
-    return handle;
-}
-
 void
-NegWindow::glDrawTexture (GLTexture          *texture,
-			  GLFragment::Attrib &attrib,
-			  unsigned int       mask)
+NegWindow::glDrawTexture (GLTexture                 *texture,
+                          const GLMatrix            &transform,
+                          const GLWindowPaintAttrib &attrib,
+                          unsigned int              mask)
 {
-    GLTexture::Filter filter;
     bool              doNeg = false;
     GLTexture         *tex = NULL;
 
@@ -160,24 +112,16 @@
 
     if (doNeg && tex)
     {
-	/* Fragment program negation */
-	if (GL::fragmentProgram)
+	/* shader program negation */
+	if (true)
 	{
-	    GLFragment::Attrib fa = attrib;
-	    int                function;
-	    bool               alpha = true;
-
-	    if (texture->name () == tex->name ()) /* Not a decoration */
-		alpha = window->alpha ();
-
-	    function = ns->getFragmentFunction (texture, alpha);
-	    if (function)
-		fa.addFunction (function);
-
-	    gWindow->glDrawTexture (texture, fa, mask);
+	    gWindow->addShaders ("neg", "", fragment_function);
+	    gWindow->glDrawTexture (texture, transform, attrib, mask);
 	}
 	else /* Texture manipulation negation */
 	{
+#ifndef USE_GLES
+	    GLTexture::Filter filter;
 	    /* this is for the most part taken from paint.c */
 
 	    if (mask & PAINT_WINDOW_TRANSFORMED_MASK)
@@ -188,14 +132,10 @@
 		filter = ns->gScreen->filter (NOTHING_TRANS_FILTER);
 
 	    /* if we can adjust saturation, even if it's just on and off */
-	    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
+	    if (GL::canDoSaturated && attrib.saturation != COLOR)
 	    {
 		GLfloat constant[4];
 
-		/* if the paint mask has this set we want to blend */
-		if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
-		    glEnable (GL_BLEND);
-
 		/* enable the texture */
 		texture->enable (filter);
 
@@ -233,7 +173,7 @@
 		glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
 
 		/* if we can do saturation that is in between min and max */
-		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);
@@ -270,13 +210,13 @@
 		    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
 
     		    /* color constant */
-		    constant[3] = attrib.getSaturation () / 65535.0f;
+		    constant[3] = attrib.saturation / 65535.0f;
 
 		    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
     		    /* if we are not opaque or not fully bright */
-		    if (attrib.getOpacity () < OPAQUE ||
-			attrib.getBrightness () != BRIGHT)
+		    if (attrib.opacity < OPAQUE ||
+			attrib.brightness != BRIGHT)
 		    {
 			/* make another texture active */
 			GL::activeTexture (GL_TEXTURE3_ARB);
@@ -285,9 +225,9 @@
 			texture->enable (filter);
 
 			/* color constant */
-			constant[3] = attrib.getOpacity () / 65535.0f;
+			constant[3] = attrib.opacity / 65535.0f;
 			constant[0] = constant[1] = constant[2] =
-			    constant[3] * attrib.getBrightness () / 65535.0f;
+			    constant[3] * attrib.brightness / 65535.0f;
 
 			glTexEnvfv(GL_TEXTURE_ENV,
 				   GL_TEXTURE_ENV_COLOR, constant);
@@ -314,8 +254,7 @@
 			glTexEnvf(GL_TEXTURE_ENV,
 				  GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
-			/* draw the window geometry */
-			gWindow->glDrawGeometry ();
+			gWindow->glDrawTexture (texture, transform, attrib, mask);
 
 			/* disable the current texture */
 			texture->disable ();
@@ -331,8 +270,7 @@
 		    {
 			/* fully opaque and bright */
 
-			/* draw the window geometry */
-			gWindow->glDrawGeometry ();
+			gWindow->glDrawTexture (texture, transform, attrib, mask);
 		    }
 
 		    /* disable the current texture */
@@ -355,9 +293,9 @@
 		    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
     		    /* color constant */
-		    constant[3] = attrib.getOpacity () / 65535.0f;
+		    constant[3] = attrib.opacity / 65535.0f;
 		    constant[0] = constant[1] = constant[2] =
-			constant[3] * attrib.getBrightness () / 65535.0f;
+			constant[3] * attrib.brightness / 65535.0f;
 
 		    constant[0] =
 			0.5f + 0.5f * RED_SATURATION_WEIGHT * constant[0];
@@ -368,8 +306,7 @@
 
 		    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
-    		    /* draw the window geometry */
-		    gWindow->glDrawGeometry ();
+		    gWindow->glDrawTexture (texture, transform, attrib, mask);
 		}
 
 		/* disable the current texture */
@@ -390,9 +327,6 @@
 		/* set screens texture mode back to replace */
 		ns->gScreen->setTexEnvMode (GL_REPLACE);
 
-		/* if it's a translucent window, disable blending */
-		if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
-		    glDisable (GL_BLEND);
 	    }
 	    else
 	    {
@@ -411,17 +345,14 @@
 
 		/* we are not opaque or fully bright */
 		if ((mask & PAINT_WINDOW_TRANSLUCENT_MASK) ||
-		    attrib.getBrightness () != BRIGHT)
+		    attrib.brightness != BRIGHT)
 		{
 		    GLfloat constant[4];
 
-		    /* enable blending */
-		    glEnable (GL_BLEND);
-
 		    /* color constant */
-		    constant[3] = attrib.getOpacity () / 65535.0f;
+		    constant[3] = attrib.opacity / 65535.0f;
 		    constant[0] = constant[1] = constant[2] =
-			constant[3] * attrib.getBrightness () / 65535.0f;
+			constant[3] * attrib.brightness / 65535.0f;
 
 		    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 		    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
@@ -441,18 +372,13 @@
 		    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
 		    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
-    		    /* draw the window geometry */
-		    gWindow->glDrawGeometry ();
-
-		    /* disable blending */
-		    glDisable (GL_BLEND);
+		    gWindow->glDrawTexture (texture, transform, attrib, mask);
 		}
 		else
 		{
 		    /* no adjustments to saturation, brightness or opacity */
 
-		    /* draw the window geometry */
-		    gWindow->glDrawGeometry ();
+		    gWindow->glDrawTexture (texture, transform, attrib, mask);
 		}
 
 		/* disable the current texture */
@@ -461,12 +387,13 @@
 		/* set the screens texture mode back to replace */
 		ns->gScreen->setTexEnvMode (GL_REPLACE);
 	    }
+#endif
 	}
     }
     else
     {
 	/* not negative */
-	gWindow->glDrawTexture (texture, attrib, mask);
+	gWindow->glDrawTexture (texture, transform, attrib, mask);
     }
 }
 
@@ -524,7 +451,7 @@
 					  _1, _2));
     optionSetExcludeMatchNotify (boost::bind (&NegScreen::optionChanged, this,
 					      _1, _2));
-	optionSetNegDecorationsNotify (boost::bind (&NegScreen::optionChanged, this,
+    optionSetNegDecorationsNotify (boost::bind (&NegScreen::optionChanged, this,
 					  _1, _2));
 
 }

=== modified file 'plugins/neg/src/neg.h'
--- plugins/neg/src/neg.h	2011-05-27 08:32:06 +0000
+++ plugins/neg/src/neg.h	2012-05-26 15:11:19 +0000
@@ -57,10 +57,6 @@
 		CompOption::Vector opt,
 		bool		   all);
 
-	int
-	getFragmentFunction (GLTexture *texture,
-			     bool      alpha);
-
 	GLScreen *gScreen;
 };
 
@@ -89,9 +85,10 @@
 	bool isNeg;
 
 	void
-	glDrawTexture(GLTexture          *texture,
-		      GLFragment::Attrib &attrib,
-		      unsigned int       mask);
+	glDrawTexture (GLTexture                 *texture,
+	               const GLMatrix            &transform,
+	               const GLWindowPaintAttrib &attrib,
+	               unsigned int              mask);
 
 	void toggle ();
 };

=== modified file 'plugins/obs/src/obs.cpp'
--- plugins/obs/src/obs.cpp	2010-07-02 02:49:24 +0000
+++ plugins/obs/src/obs.cpp	2012-05-26 15:11:19 +0000
@@ -151,29 +151,30 @@
 	 we wrap into glDrawWindow here */
 
 bool
-ObsWindow::glDraw (const GLMatrix&     transform,
-		   GLFragment::Attrib& attrib,
-		   const CompRegion&   region,
-		   unsigned int        mask)
+ObsWindow::glDraw (const GLMatrix            &transform,
+		   const GLWindowPaintAttrib &attrib,
+		   const CompRegion          &region,
+		   unsigned int              mask)
 {
+    GLWindowPaintAttrib wAttrib (attrib);
     int factor;
 
     factor = customFactor[MODIFIER_OPACITY];
     if (factor != 100)
     {
-	attrib.setOpacity (factor * attrib.getOpacity () / 100);
+	wAttrib.opacity = factor * wAttrib.opacity / 100;
 	mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
     }
 
     factor = customFactor[MODIFIER_BRIGHTNESS];
     if (factor != 100)
-	attrib.setBrightness (factor * attrib.getBrightness () / 100);
+	wAttrib.brightness = factor * wAttrib.brightness / 100;
 
     factor = customFactor[MODIFIER_SATURATION];
     if (factor != 100)
-	attrib.setSaturation (factor * attrib.getSaturation () / 100);
+	wAttrib.saturation = factor * wAttrib.saturation / 100;
 
-    return gWindow->glDraw (transform, attrib, region, mask);
+    return gWindow->glDraw (transform, wAttrib, region, mask);
 }
 
 void

=== modified file 'plugins/obs/src/obs.h'
--- plugins/obs/src/obs.h	2012-01-18 16:26:45 +0000
+++ plugins/obs/src/obs.h	2012-05-26 15:11:19 +0000
@@ -66,7 +66,7 @@
 
 	bool glPaint (const GLWindowPaintAttrib &, const GLMatrix &,
 		      const CompRegion &, unsigned int);
-	bool glDraw (const GLMatrix &, GLFragment::Attrib &,
+	bool glDraw (const GLMatrix &, const GLWindowPaintAttrib &,
 		     const CompRegion &, unsigned int);
 
 	void changePaintModifier (unsigned int, int);

=== modified file 'plugins/opengl/CMakeLists.txt'
--- plugins/opengl/CMakeLists.txt	2009-03-15 05:09:18 +0000
+++ plugins/opengl/CMakeLists.txt	2012-05-26 15:11:19 +0000
@@ -2,7 +2,12 @@
 
 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)
+

=== modified file 'plugins/opengl/compiz-opengl.pc.in'
--- plugins/opengl/compiz-opengl.pc.in	2009-03-15 05:09:18 +0000
+++ plugins/opengl/compiz-opengl.pc.in	2012-05-26 15:11:19 +0000
@@ -8,5 +8,5 @@
 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

=== removed file 'plugins/opengl/include/opengl/fragment.h'
--- plugins/opengl/include/opengl/fragment.h	2012-01-18 16:26:45 +0000
+++ plugins/opengl/include/opengl/fragment.h	1970-01-01 00:00:00 +0000
@@ -1,125 +0,0 @@
-/*
- * Copyright © 2008 Dennis Kasprzyk
- * Copyright © 2007 Novell, Inc.
- *
- * 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
- * Dennis Kasprzyk not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Dennis Kasprzyk makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL DENNIS KASPRZYK 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: Dennis Kasprzyk <[e-mail]>
- *          David Reveman <[e-mail]>
- */
-
-#ifndef _GLFRAGMENT_H
-#define _GLFRAGMENT_H
-
-#define MAX_FRAGMENT_FUNCTIONS 16
-
-#define COMP_FETCH_TARGET_2D   0
-#define COMP_FETCH_TARGET_RECT 1
-#define COMP_FETCH_TARGET_NUM  2
-
-struct GLWindowPaintAttrib;
-class GLScreen;
-class GLTexture;
-
-/**
- * Describes a texture modification fragment program
- * for a texture
- */
-namespace GLFragment {
-
-    class Storage;
-
-    typedef unsigned int FunctionId;
-
-    class PrivateFunctionData;
-    class PrivateAttrib;
-
-    class FunctionData {
-	public:
-	    FunctionData ();
-	    ~FunctionData ();
-
-	    /**
-	     * Returns the status of this fragment program
-	     * (valid or invalid)
-	     */
-	    bool status ();
-
-	    void addTempHeaderOp (const char *name);
-
-	    void addParamHeaderOp (const char *name);
-
-	    void addAttribHeaderOp (const char *name);
-
-
-	    void addFetchOp (const char *dst, const char *offset, int target);
-
-	    void addColorOp (const char *dst, const char *src);
-
-	    void addDataOp (const char *str, ...);
-
-	    void addBlendOp (const char *str, ...);
-
-	    FunctionId createFragmentFunction (const char *name);
-
-	private:
-	    PrivateFunctionData *priv;
-    };
-
-    class Attrib {
-	public:
-	    Attrib (const GLWindowPaintAttrib &paint);
-	    Attrib (const Attrib&);
-	    ~Attrib ();
-
-	    Attrib &operator= (const Attrib &rhs);
-
-	    unsigned int allocTextureUnits (unsigned int nTexture);
-
-	    unsigned int allocParameters (unsigned int nParam);
-
-	    void addFunction (FunctionId function);
-
-	    bool enable (bool *blending);
-	    void disable ();
-
-	    unsigned short getSaturation ();
-	    unsigned short getBrightness ();
-	    unsigned short getOpacity ();
-
-	    void setSaturation (unsigned short);
-	    void setBrightness (unsigned short);
-	    void setOpacity (unsigned short);
-
-	    bool hasFunctions ();
-
-	private:
-	    PrivateAttrib *priv;
-    };
-
-    void destroyFragmentFunction (FunctionId id);
-
-    FunctionId getSaturateFragmentFunction (GLTexture *texture,
-					    int       param);
-};
-
-
-
-#endif

=== added file 'plugins/opengl/include/opengl/framebufferobject.h'
--- plugins/opengl/include/opengl/framebufferobject.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/framebufferobject.h	2012-05-26 15:11:19 +0000
@@ -0,0 +1,107 @@
+/*
+ * 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]>
+ */
+
+#ifndef _COMPIZ_GLFRAMEBUFFEROBJECT_H
+#define _COMPIZ_GLFRAMEBUFFEROBJECT_H
+
+#include <opengl/opengl.h>
+
+struct PrivateGLFramebufferObject;
+
+/**
+ * Class representing a framebuffer object in GL, supporting only one
+ * color attachment as per GLES 2 spec. The color attachment is referred
+ * to as the texture (of the FBO).
+ *
+ * Usage:
+ * 1. create a GLFramebufferObject (requires a GL context)
+ * 2. call allocate (size), and check status ()
+ * 3. old = bind ()
+ * 4. do your rendering
+ * 5. rebind (old)
+ * 6. use the rendered texture via tex ()
+ * 7. go to 2 or 3, or delete to quit (requires a GL context)
+ *
+ * TODO: add depth/stencil attachments
+ * FIXME: written for OpenGL ES 2 only, desktop OpenGL might not work.
+ */
+class GLFramebufferObject
+{
+    public:
+	GLFramebufferObject ();
+	~GLFramebufferObject ();
+
+	/**
+	 * Ensure the texture is of the given size, recreating it if needed,
+	 * and replace the FBO color attachment with it. The texture contents
+	 * become undefined, unless specified in the 'image' argument.
+	 * When specifying 'image', it's also possible to pass-in the
+	 * desired image's 'format' and 'type'.
+	 *
+	 * Returns true on success, and false on texture allocation failure.
+	 */
+	bool allocate (const CompSize &size,
+		       const char *image = NULL,
+		       GLenum format = GL_RGBA,
+		       GLenum type = GL_UNSIGNED_BYTE);
+
+	/**
+	 * Bind this as the current FBO, previous binding in GL context is
+	 * undone. GL rendering is now targeted to this FBO.
+	 * Returns a pointer to the previously bound FBO, or NULL if
+	 * the previous binding was zero (the window system provided
+	 * framebuffer).
+	 *
+	 * The previous FBO is no longer bound, so you can use its
+	 * texture. To restore the previous FBO, call rebind (FBO) with
+	 * the returned pointer as the argument.
+	 */
+	GLFramebufferObject *bind ();
+
+	/**
+	 * Bind the given FBO as the current FBO, without looking up the
+	 * previous binding. The argument can be NULL, in which case the
+	 * window system provided framebuffer gets bound (FBO is unbound).
+	 */
+	static void rebind (GLFramebufferObject *fbo);
+
+	/**
+	 * Check the FBO completeness. Returns true on complete.
+	 * Otherwise returns false and reports the error to log.
+	 */
+	bool checkStatus ();
+
+	/**
+	 * Return a pointer to the texture that is the color attachment.
+	 * This will return NULL, if allocate () has not been called, or
+	 * the last allocate () call failed.
+	 */
+	GLTexture *tex ();
+
+    private:
+	PrivateGLFramebufferObject *priv;
+};
+
+#endif // _COMPIZ_GLFRAMEBUFFEROBJECT_H

=== modified file 'plugins/opengl/include/opengl/matrix.h'
--- plugins/opengl/include/opengl/matrix.h	2009-03-15 05:09:18 +0000
+++ plugins/opengl/include/opengl/matrix.h	2012-05-26 15:11:19 +0000
@@ -44,6 +44,8 @@
 	void reset ();
 	void toScreenSpace (const CompOutput *output, float z);
 
+	bool invert ();
+
 	void rotate (const float angle, const float x,
 		     const float y, const float z);
 	void rotate (const float angle, const GLVector& vector);

=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2012-01-20 09:05:56 +0000
+++ plugins/opengl/include/opengl/opengl.h	2012-05-26 15:11:19 +0000
@@ -28,16 +28,45 @@
 #ifndef _COMPIZ_OPENGL_H
 #define _COMPIZ_OPENGL_H
 
+#ifdef USE_GLES
+#define SUPPORT_X11
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
 #include <GL/gl.h>
 #include <GL/glx.h>
+#endif
+
+#include <core/size.h>
+#include <core/pluginclasshandler.h>
 
 #include <opengl/matrix.h>
 #include <opengl/texture.h>
-#include <opengl/fragment.h>
+#include <opengl/framebufferobject.h>
+#include <opengl/vertexbuffer.h>
+#include <opengl/program.h>
+#include <opengl/programcache.h>
+#include <opengl/shadercache.h>
 
 #define COMPIZ_OPENGL_ABI 4
 
-#include <core/pluginclasshandler.h>
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
+
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
 
 /**
  * camera distance from screen, 0.5 * tan (FOV)
@@ -75,8 +104,26 @@
 #endif
 
 namespace GL {
-
+    #ifdef USE_GLES
+    typedef EGLImageKHR (*EGLCreateImageKHRProc)  (EGLDisplay dpy,
+                                                   EGLContext ctx,
+                                                   EGLenum target,
+                                                   EGLClientBuffer buffer,
+                                                   const EGLint *attrib_list);
+    typedef EGLBoolean  (*EGLDestroyImageKHRProc) (EGLDisplay dpy,
+                                                   EGLImageKHR image);
+
+    typedef void (*GLEGLImageTargetTexture2DOESProc) (GLenum target,
+                                                      GLeglImageOES image);
+
+    typedef EGLBoolean (*EGLPostSubBufferNVProc) (EGLDisplay dpy,
+						  EGLSurface surface,
+						  EGLint x, EGLint y,
+						  EGLint width, EGLint height);
+
+    #else
     typedef void (*FuncPtr) (void);
+
     typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
 
     typedef void    (*GLXBindTexImageProc)    (Display	 *display,
@@ -122,11 +169,6 @@
 					      const int   *attribList);
     typedef void      (*GLXDestroyPixmapProc) (Display *display,
     					       GLXPixmap pixmap);
-
-    typedef void (*GLActiveTextureProc) (GLenum texture);
-    typedef void (*GLClientActiveTextureProc) (GLenum texture);
-    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
-
     typedef void (*GLGenProgramsProc) (GLsizei n,
 				       GLuint  *programs);
     typedef void (*GLDeleteProgramsProc) (GLsizei n,
@@ -146,11 +188,16 @@
     typedef void (*GLGetProgramivProc) (GLenum target,
 					GLenum pname,
 					int    *params);
+    #endif
+
+    typedef void (*GLActiveTextureProc) (GLenum texture);
+    typedef void (*GLClientActiveTextureProc) (GLenum texture);
+    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
 
     typedef void (*GLGenFramebuffersProc) (GLsizei n,
 					   GLuint  *framebuffers);
     typedef void (*GLDeleteFramebuffersProc) (GLsizei n,
-					      GLuint  *framebuffers);
+					      const GLuint  *framebuffers);
     typedef void (*GLBindFramebufferProc) (GLenum target,
 					   GLuint framebuffer);
     typedef GLenum (*GLCheckFramebufferStatusProc) (GLenum target);
@@ -161,6 +208,96 @@
 						GLint  level);
     typedef void (*GLGenerateMipmapProc) (GLenum target);
 
+    typedef void (*GLBindBufferProc) (GLenum target,
+                                      GLuint buffer);
+    typedef void (*GLDeleteBuffersProc) (GLsizei n,
+                                         const GLuint *buffers);
+    typedef void (*GLGenBuffersProc) (GLsizei n,
+                                      GLuint *buffers);
+    typedef void (*GLBufferDataProc) (GLenum target,
+                                      GLsizeiptr size,
+                                      const GLvoid *data,
+                                      GLenum usage);
+    typedef void (*GLBufferSubDataProc) (GLenum target,
+                                         GLintptr offset,
+                                         GLsizeiptr size,
+                                         const GLvoid *data);
+
+    typedef void (*GLGetShaderivProc) (GLuint shader,
+                                       GLenum pname,
+                                       GLint *params);
+    typedef void (*GLGetShaderInfoLogProc) (GLuint shader,
+                                            GLsizei bufsize,
+                                            GLsizei *length,
+                                            GLchar *infoLog);
+    typedef void (*GLGetProgramivProc) (GLuint program,
+                                        GLenum pname,
+                                        GLint* params);
+    typedef void (*GLGetProgramInfoLogProc) (GLuint program,
+                                             GLsizei bufsize,
+                                             GLsizei *length,
+                                             GLchar *infoLog);
+    typedef GLuint (*GLCreateShaderProc) (GLenum type);
+    typedef void (*GLShaderSourceProc) (GLuint shader,
+                                        GLsizei count,
+                                        const GLchar **string,
+                                        const GLint* length);
+    typedef void (*GLCompileShaderProc) (GLuint shader);
+    typedef GLuint (*GLCreateProgramProc) ();
+    typedef void (*GLAttachShaderProc) (GLuint program,
+                                        GLuint shader);
+    typedef void (*GLLinkProgramProc) (GLuint program);
+    typedef void (*GLValidateProgramProc) (GLuint program);
+    typedef void (*GLDeleteShaderProc) (GLuint shader);
+    typedef void (*GLDeleteProgramProc) (GLuint program);
+    typedef void (*GLUseProgramProc) (GLuint program);
+    typedef int  (*GLGetUniformLocationProc) (GLuint program,
+                                              const GLchar* name);
+    typedef void (*GLUniform1fProc) (GLint location, GLfloat x);
+    typedef void (*GLUniform1iProc) (GLint location, GLint x);
+    typedef void (*GLUniform2fProc) (GLint location, GLfloat x, GLfloat y);
+    typedef void (*GLUniform3fProc) (GLint location,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z);
+    typedef void (*GLUniform4fProc) (GLint location,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z,
+                                     GLfloat w);
+    typedef void (*GLUniform2iProc) (GLint location, GLint x, GLint y);
+    typedef void (*GLUniform3iProc) (GLint location,
+                                     GLint x,
+                                     GLint y,
+                                     GLint z);
+    typedef void (*GLUniform4iProc) (GLint location,
+                                     GLint x,
+                                     GLint y,
+                                     GLint z,
+                                     GLint w);
+    typedef void (*GLUniformMatrix4fvProc) (GLint location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value);
+    typedef int (*GLGetAttribLocationProc) (GLuint program,
+                                            const GLchar *name);
+
+    typedef void (*GLEnableVertexAttribArrayProc) (GLuint index);
+    typedef void (*GLDisableVertexAttribArrayProc) (GLuint index);
+    typedef void (*GLVertexAttribPointerProc) (GLuint index,
+                                               GLint size,
+                                               GLenum type,
+                                               GLboolean normalized,
+                                               GLsizei stride,
+                                               const GLvoid *ptr);
+
+    #ifdef USE_GLES
+    extern EGLCreateImageKHRProc  createImage;
+    extern EGLDestroyImageKHRProc destroyImage;
+
+    extern GLEGLImageTargetTexture2DOESProc eglImageTargetTexture;
+
+    #else
     extern GLXBindTexImageProc      bindTexImage;
     extern GLXReleaseTexImageProc   releaseTexImage;
     extern GLXQueryDrawableProc     queryDrawable;
@@ -172,11 +309,6 @@
     extern GLXGetFBConfigAttribProc getFBConfigAttrib;
     extern GLXCreatePixmapProc      createPixmap;
     extern GLXDestroyPixmapProc     destroyPixmap;
-
-    extern GLActiveTextureProc       activeTexture;
-    extern GLClientActiveTextureProc clientActiveTexture;
-    extern GLMultiTexCoord2fProc     multiTexCoord2f;
-
     extern GLGenProgramsProc        genPrograms;
     extern GLDeleteProgramsProc     deletePrograms;
     extern GLBindProgramProc        bindProgram;
@@ -184,6 +316,11 @@
     extern GLProgramParameter4fProc programEnvParameter4f;
     extern GLProgramParameter4fProc programLocalParameter4f;
     extern GLGetProgramivProc       getProgramiv;
+    #endif
+
+    extern GLActiveTextureProc       activeTexture;
+    extern GLClientActiveTextureProc clientActiveTexture;
+    extern GLMultiTexCoord2fProc     multiTexCoord2f;
 
     extern GLGenFramebuffersProc        genFramebuffers;
     extern GLDeleteFramebuffersProc     deleteFramebuffers;
@@ -192,16 +329,56 @@
     extern GLFramebufferTexture2DProc   framebufferTexture2D;
     extern GLGenerateMipmapProc         generateMipmap;
 
+    extern GLBindBufferProc    bindBuffer;
+    extern GLDeleteBuffersProc deleteBuffers;
+    extern GLGenBuffersProc    genBuffers;
+    extern GLBufferDataProc    bufferData;
+    extern GLBufferSubDataProc bufferSubData;
+
+
+    extern GLGetShaderivProc        getShaderiv;
+    extern GLGetShaderInfoLogProc   getShaderInfoLog;
+    extern GLGetProgramivProc       getProgramiv;
+    extern GLGetProgramInfoLogProc  getProgramInfoLog;
+    extern GLCreateShaderProc       createShader;
+    extern GLShaderSourceProc       shaderSource;
+    extern GLCompileShaderProc      compileShader;
+    extern GLCreateProgramProc      createProgram;
+    extern GLAttachShaderProc       attachShader;
+    extern GLLinkProgramProc        linkProgram;
+    extern GLValidateProgramProc    validateProgram;
+    extern GLDeleteShaderProc       deleteShader;
+    extern GLDeleteProgramProc      deleteProgram;
+    extern GLUseProgramProc         useProgram;
+    extern GLGetUniformLocationProc getUniformLocation;
+    extern GLUniform1fProc          uniform1f;
+    extern GLUniform1iProc          uniform1i;
+    extern GLUniform2fProc          uniform2f;
+    extern GLUniform2iProc          uniform2i;
+    extern GLUniform3fProc          uniform3f;
+    extern GLUniform3iProc          uniform3i;
+    extern GLUniform4fProc          uniform4f;
+    extern GLUniform4iProc          uniform4i;
+    extern GLUniformMatrix4fvProc   uniformMatrix4fv;
+    extern GLGetAttribLocationProc  getAttribLocation;
+
+    extern GLEnableVertexAttribArrayProc  enableVertexAttribArray;
+    extern GLDisableVertexAttribArrayProc disableVertexAttribArray;
+    extern GLVertexAttribPointerProc      vertexAttribPointer;
+
+
     extern bool  textureFromPixmap;
     extern bool  textureRectangle;
     extern bool  textureNonPowerOfTwo;
+    extern bool  textureNonPowerOfTwoMipmap;
     extern bool  textureEnvCombine;
     extern bool  textureEnvCrossbar;
     extern bool  textureBorderClamp;
     extern bool  textureCompression;
     extern GLint maxTextureSize;
     extern bool  fbo;
-    extern bool  fragmentProgram;
+    extern bool  vbo;
+    extern bool  shaders;
     extern GLint maxTextureUnits;
 
     extern bool canDoSaturated;
@@ -220,6 +397,7 @@
 
 #define MAX_DEPTH 32
 
+#ifndef USE_GLES
 struct GLFBConfig {
     GLXFBConfig fbConfig;
     int         yInverted;
@@ -227,6 +405,7 @@
     int         textureFormat;
     int         textureTargets;
 };
+#endif
 
 #define NOTHING_TRANS_FILTER 0
 #define SCREEN_TRANS_FILTER  1
@@ -236,6 +415,7 @@
 extern GLScreenPaintAttrib defaultScreenPaintAttrib;
 
 class GLScreen;
+class GLFramebufferObject;
 
 class GLScreenInterface :
     public WrapableInterface<GLScreen, GLScreenInterface>
@@ -302,11 +482,24 @@
 					     CompOutput *);
 	virtual void glDisableOutputClipping ();
 
+	virtual GLMatrix *projectionMatrix ();
+
+	/**
+	 * Hookable function used by plugins to shade the final composited
+	 * Output.
+	 *
+	 * @param tmpRegion Describes the final composited output region
+	 * @param scratchFbo Describes the final composited FBO that is
+	 * to be rendered.
+	 */
+	virtual void glPaintCompositedOutput (const CompRegion    &region,
+					      GLFramebufferObject *fbo,
+					      unsigned int         mask);
 };
 
 
 class GLScreen :
-    public WrapableHandler<GLScreenInterface, 6>,
+    public WrapableHandler<GLScreenInterface, 7>,
     public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
     public CompOption::Class
 {
@@ -332,7 +525,9 @@
 	/**
 	 * Gets the libGL address of a particular openGL functor
 	 */
+	#ifndef USE_GLES
 	GL::FuncPtr getProcAddress (const char *name);
+	#endif
 
 	void updateBackground ();
 
@@ -346,8 +541,6 @@
 	 */
 	void setFilter (int, GLTexture::Filter);
 
-	GLFragment::Storage * fragmentStorage ();
-
 	/**
 	 * Sets a new compiz-wid openGL texture environment mode
 	 */
@@ -356,7 +549,6 @@
 	/**
 	 * Turns lighting on and off
 	 */
-
 	void setLighting (bool lighting);
 
 	/**
@@ -371,7 +563,28 @@
 	GLTexture::BindPixmapHandle registerBindPixmap (GLTexture::BindPixmapProc);
 	void unregisterBindPixmap (GLTexture::BindPixmapHandle);
 
+	#ifndef USE_GLES
 	GLFBConfig * glxPixmapFBConfig (unsigned int depth);
+	#endif
+
+	#ifdef USE_GLES
+	EGLContext getEGLContext ();
+	#endif
+
+	/**
+	 * Returns a GLProgram from the cache or creates one and caches it
+	 */
+	GLProgram *getProgram (std::list<const GLShaderData*>);
+
+	/**
+	 * Returns a GLShaderData from the cache or creates one and caches it
+	 */
+	const GLShaderData *getShaderData (GLShaderParameters &params);
+
+	/**
+	 * Returns the FBO compiz is using for the screen
+	 */
+	GLFramebufferObject *fbo ();
 
 	/**
 	 * Returns a default icon texture
@@ -380,12 +593,6 @@
 
 	void resetRasterPos ();
 
-	/**
-	 * Returns a 4x4 const float array which
-	 * represents the current projection matrix
-	 */
-	const float * projectionMatrix ();
-
 	bool glInitContext (XVisualInfo *);
 
 	WRAPABLE_HND (0, GLScreenInterface, bool, glPaintOutput,
@@ -402,7 +609,12 @@
 		      const GLMatrix &, const CompRegion &, CompOutput *);
 	WRAPABLE_HND (4, GLScreenInterface, void, glDisableOutputClipping);
 
+	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
+	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
+		      const CompRegion &, GLFramebufferObject *, unsigned int);
+
 	friend class GLTexture;
+	friend class GLWindow;
 
     private:
 	PrivateGLScreen *priv;
@@ -453,10 +665,10 @@
 	 * @param region Describes which region will be drawn
 	 * @param mask   Bitmask which describes how this window is drawn
 	 */
-	virtual bool glDraw (const GLMatrix 	&matrix,
-			     GLFragment::Attrib &attrib,
-			     const CompRegion 	&region,
-			     unsigned int	mask);
+	virtual bool glDraw (const GLMatrix 	       &matrix,
+			     const GLWindowPaintAttrib &attrib,
+			     const CompRegion 	       &region,
+			     unsigned int              mask);
 
 	/**
 	 * Hookable function to add points to a window
@@ -479,51 +691,18 @@
 				    const CompRegion 		&clipRegion,
 				    unsigned int		min = MAXSHORT,
 				    unsigned int		max = MAXSHORT);
-	virtual void glDrawTexture (GLTexture *texture, GLFragment::Attrib &,
-				    unsigned int);
-	virtual void glDrawGeometry ();
+	virtual void glDrawTexture (GLTexture *texture, const GLMatrix &,
+	                            const GLWindowPaintAttrib &, unsigned int);
 };
 
 class GLWindow :
-    public WrapableHandler<GLWindowInterface, 5>,
+    public WrapableHandler<GLWindowInterface, 4>,
     public PluginClassHandler<GLWindow, CompWindow, COMPIZ_OPENGL_ABI>
 {
     public:
 
-	/**
-	 * Class which describes the texture geometry and transformation points
-	 * of a window
-	 */
-	class Geometry {
-	    public:
-		Geometry ();
-		~Geometry ();
-
-		void reset ();
-
-		/**
-		 * Set the number of vertices in the texture geometry
-		 */
-		bool moreVertices (int newSize);
-
-		/**
-		 * Set the number of indices in the texture geometry
-		 */
-		bool moreIndices (int newSize);
-
-	    public:
-		GLfloat  *vertices;
-		int      vertexSize;
-		int      vertexStride;
-		GLushort *indices;
-		int      indexSize;
-		int      vCount;
-		int      texUnits;
-		int      texCoordSize;
-		int      indexCount;
-	};
-
 	static GLWindowPaintAttrib defaultPaintAttrib;
+
     public:
 
 	GLWindow (CompWindow *w);
@@ -566,9 +745,20 @@
 	void updatePaintAttribs ();
 
 	/**
-	 * Returns the window texture geometry
-	 */
-	Geometry & geometry ();
+	 * Returns the window vertex buffer object
+	 */
+	GLVertexBuffer * vertexBuffer ();
+
+	/**
+	 * Add a vertex and/or fragment shader function to the pipeline.
+	 *
+	 * @param name Name of the plugin adding the functions
+	 * @param vertex_shader Function to add to the vertex shader
+	 * @param fragment_shader Function to add to the fragment shader
+	 */
+	void addShaders (std::string name,
+	                 std::string vertex_shader,
+	                 std::string fragment_shader);
 
 	GLTexture *getIcon (int width, int height);
 
@@ -576,14 +766,15 @@
 		      const GLWindowPaintAttrib &, const GLMatrix &,
 		      const CompRegion &, unsigned int);
 	WRAPABLE_HND (1, GLWindowInterface, bool, glDraw, const GLMatrix &,
-		      GLFragment::Attrib &, const CompRegion &, unsigned int);
+		      const GLWindowPaintAttrib &, const CompRegion &,
+	              unsigned int);
 	WRAPABLE_HND (2, GLWindowInterface, void, glAddGeometry,
 		      const GLTexture::MatrixList &, const CompRegion &,
 		      const CompRegion &,
 		      unsigned int = MAXSHORT, unsigned int = MAXSHORT);
 	WRAPABLE_HND (3, GLWindowInterface, void, glDrawTexture,
-		      GLTexture *texture, GLFragment::Attrib &, unsigned int);
-	WRAPABLE_HND (4, GLWindowInterface, void, glDrawGeometry);
+		      GLTexture *texture, const GLMatrix &,
+	              const GLWindowPaintAttrib &, unsigned int);
 
 	friend class GLScreen;
 	friend class PrivateGLScreen;
@@ -593,3 +784,4 @@
 };
 
 #endif
+

=== added file 'plugins/opengl/include/opengl/program.h'
--- plugins/opengl/include/opengl/program.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/program.h	2012-05-26 15:11:19 +0000
@@ -0,0 +1,75 @@
+/*
+ * 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]>
+ */
+
+#ifndef _COMPIZ_GLPROGRAM_H
+#define _COMPIZ_GLPROGRAM_H
+
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include <core/core.h>
+#include <opengl/matrix.h>
+
+class PrivateProgram;
+
+class GLProgram
+{
+    public:
+	GLProgram (CompString &vertexShader, CompString &fragmentShader);
+	~GLProgram ();
+
+	bool valid ();
+	void bind ();
+	void unbind ();
+
+	bool setUniform   (const char *name, GLfloat value);
+	bool setUniform   (const char *name, GLint value);
+	bool setUniform   (const char *name, const GLMatrix &value);
+	bool setUniform2f (const char *name, GLfloat x, GLfloat y);
+	bool setUniform3f (const char *name, GLfloat x, GLfloat y, GLfloat z);
+	bool setUniform4f (const char *name,
+	                   GLfloat x,
+	                   GLfloat y,
+	                   GLfloat z,
+                           GLfloat w);
+	bool setUniform2i (const char *name, GLint x, GLint y);
+	bool setUniform3i (const char *name, GLint x, GLint y, GLint z);
+	bool setUniform4i (const char *name,
+	                   GLint x,
+	                   GLint y,
+	                   GLint z,
+                           GLint w);
+
+	GLuint attributeLocation (const char *name);
+
+    private:
+	PrivateProgram *priv;
+};
+
+#endif // _COMPIZ_GLPROGRAM_H
+

=== added file 'plugins/opengl/include/opengl/programcache.h'
--- plugins/opengl/include/opengl/programcache.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/programcache.h	2012-05-26 15:11:19 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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]>
+ */
+
+#ifndef _COMPIZ_GLPROGRAMCACHE_H
+#define _COMPIZ_GLPROGRAMCACHE_H
+
+#include <string>
+#include <list>
+#include <map>
+#include <boost/bind.hpp>
+#include <opengl/program.h>
+
+class PrivateProgramCache;
+struct GLShaderData;
+
+class GLProgramCache
+{
+    private:
+	PrivateProgramCache *priv;
+
+    public:
+	GLProgramCache (size_t);
+	~GLProgramCache ();
+
+	GLProgram* operator () (std::list<const GLShaderData*>);
+};
+
+#endif // _COMPIZ_GLPROGRAMCACHE_H
+

=== added file 'plugins/opengl/include/opengl/shadercache.h'
--- plugins/opengl/include/opengl/shadercache.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/shadercache.h	2012-05-26 15:11:19 +0000
@@ -0,0 +1,100 @@
+/*
+ * 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]>
+ */
+#ifndef GL_SHADER_CACHE_H_
+#define GL_SHADER_CACHE_H_
+
+#include <string>
+
+/**
+ * How to use a variable in a shader.
+ */
+enum GLShaderVariableType
+{
+    /** The variable is not used */
+    GLShaderVariableNone,
+    /** The variable value is held in a uniform */
+    GLShaderVariableUniform,
+    /** The variable value is held in a varying (from a vertex attribute) */
+    GLShaderVariableVarying,
+};
+
+/**
+ * Parameters that define a vertex-fragment shader pair.
+ */
+struct GLShaderParameters
+{
+    /** Whether this shader supports opacity */
+    bool opacity;
+    /** Whether this shader supports brightness */
+    bool brightness;
+    /** Whether this shader supports saturation */
+    bool saturation;
+    /** Whether this shader supports color and how */
+    GLShaderVariableType color;
+    /** Whether this shader supports normals and how */
+    GLShaderVariableType normal;
+    /** The number of textures this shader uses */
+    int numTextures;
+
+    /** Gets a minimalistic string representation of the parameters */
+    std::string id() const;
+    /** Gets a unique hash value for this set of parameters */
+    int hash() const;
+};
+
+/**
+ * An object representing a named vertex-fragment shader pair.
+ */
+struct GLShaderData
+{
+    std::string name;
+    std::string vertexShader;
+    std::string fragmentShader;
+};
+
+class PrivateShaderCache;
+
+/**
+ * A cache of vertex-fragment shader pairs (GLShaderData).
+ */
+class GLShaderCache
+{
+public:
+    GLShaderCache ();
+
+    /**
+     * Gets the GLShaderData associated with the specified parameters.
+     *
+     * @param params the parameters to get the GLShaderData for.
+     *
+     * @return the GLShaderData
+     */
+    const GLShaderData &getShaderData (const GLShaderParameters &params);
+
+private:
+    PrivateShaderCache *priv;
+};
+
+#endif

=== modified file 'plugins/opengl/include/opengl/texture.h'
--- plugins/opengl/include/opengl/texture.h	2012-01-18 16:26:45 +0000
+++ plugins/opengl/include/opengl/texture.h	2012-05-26 15:11:19 +0000
@@ -32,7 +32,12 @@
 #include "core/string.h"
 
 #include <X11/Xlib-xcb.h>
+
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
 #include <GL/gl.h>
+#endif
 
 #include <boost/function.hpp>
 

=== modified file 'plugins/opengl/include/opengl/vector.h'
--- plugins/opengl/include/opengl/vector.h	2010-04-03 16:24:05 +0000
+++ plugins/opengl/include/opengl/vector.h	2012-05-26 15:11:19 +0000
@@ -40,7 +40,7 @@
 	} VectorCoordsEnum;
 
 	GLVector ();
-	GLVector (float x, float y, float z, float w);
+	GLVector (float x, float y, float z, float w = 0.0f);
 
 	/**
 	 * Returns a reference to the x, y, z or w value by using
@@ -58,13 +58,13 @@
 	 * Returns a readonly x, y, z or w value by using
 	 * 0, 1, 2, 3 as array-access items
 	 */
-	const float operator[] (int item) const;
+	const float & operator[] (int item) const;
 
 	/**
 	 * Returns a readonly x, y, z or w value by using
 	 * x, y, z, w as array-access items
 	 */
-	const float operator[] (VectorCoordsEnum coord) const;
+	const float & operator[] (VectorCoordsEnum coord) const;
 
 	/**
 	 * Adds all elements in a GLVector

=== added file 'plugins/opengl/include/opengl/vertexbuffer.h'
--- plugins/opengl/include/opengl/vertexbuffer.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/vertexbuffer.h	2012-05-26 15:11:19 +0000
@@ -0,0 +1,126 @@
+/*
+ * 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 _COMPIZ_GLVERTEXBUFFER_H
+#define _COMPIZ_GLVERTEXBUFFER_H
+
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include <core/core.h>
+#include <opengl/program.h>
+#include <opengl/shadercache.h>
+
+class PrivateVertexBuffer;
+struct GLWindowPaintAttrib;
+
+namespace compiz
+{
+    namespace gl
+    {
+	class AutoProgram
+	{
+	    public:
+		virtual ~AutoProgram () {}
+
+		virtual GLProgram *getProgram(GLShaderParameters &params) = 0;
+	};
+    }
+}
+
+class GLVertexBuffer
+{
+    public:
+
+	GLVertexBuffer ();
+	GLVertexBuffer (GLenum usage);
+	~GLVertexBuffer ();
+
+	typedef compiz::gl::AutoProgram AutoProgram;
+
+	static GLVertexBuffer *streamingBuffer ();
+
+	void begin (GLenum primitiveType);
+	// default primitiveType is GL_TRIANGLES
+	void begin ();
+	int end ();
+
+	// vertices and normals are 3 parts, count is number of xyz groups
+	void addVertices (GLuint nVertices, GLfloat *vertices);
+	void addNormals (GLuint nNormals, GLfloat *normals);
+
+	// color is always RGBA (4 parts), count is number of rgba groups
+	void addColors (GLuint nColors, GLushort *colors);
+
+	void color4f (GLfloat r, GLfloat g, GLfloat b, GLfloat a);
+	void colorDefault ();
+
+	// texture is index, texcoords are 2 parts, count is number of pairs
+	void addTexCoords (GLuint texture,
+	                   GLuint nTexcoords,
+	                   GLfloat *texcoords);
+
+	void addUniform (const char *name, GLfloat value);
+	void addUniform (const char *name, GLint value);
+	bool addUniform (const char *name, const GLMatrix &value);
+	void addUniform2f (const char *name, GLfloat x, GLfloat y);
+	void addUniform3f (const char *name, GLfloat x, GLfloat y, GLfloat z);
+	void addUniform4f (const char *name, GLfloat x, GLfloat y,
+			                     GLfloat z, GLfloat w);
+	void addUniform2i (const char *name, GLint x, GLint y);
+	void addUniform3i (const char *name, GLint x, GLint y, GLint z);
+	void addUniform4i (const char *name, GLint x, GLint y,
+			                     GLint z, GLint w);
+
+	void setProgram (GLProgram *program);
+
+	void setAutoProgram (AutoProgram *autoProgram);
+
+	// This no-argument render () function is intended for use by plugins
+	// that have custom programs.
+	int render ();
+
+	int render (const GLMatrix &modelview);
+
+	int render (const GLMatrix            &modelview,
+	            const GLWindowPaintAttrib &attrib);
+
+	int render (const GLMatrix            &projection,
+	            const GLMatrix            &modelview,
+	            const GLWindowPaintAttrib &attrib);
+
+	void setVertexOffset (GLuint vOffset);
+	void setMaxVertices (GLint vMax);
+
+    private:
+	PrivateVertexBuffer *priv;
+};
+
+#endif // _COMPIZ_GLVERTEXBUFFER_H
+

=== removed file 'plugins/opengl/src/fragment.cpp'
--- plugins/opengl/src/fragment.cpp	2012-01-18 16:26:45 +0000
+++ plugins/opengl/src/fragment.cpp	1970-01-01 00:00:00 +0000
@@ -1,1146 +0,0 @@
-/*
- * Copyright © 2007 Novell, Inc.
- *
- * 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
- * Novell, Inc. not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Novell, Inc. makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL NOVELL, INC. 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.
- *
- * Author: David Reveman <[e-mail]>
- */
-
-#include "privatefragment.h"
-#include "privates.h"
-
-#include "core/string.h"
-
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
-#define foreach BOOST_FOREACH
-
-#include <opengl/texture.h>
-
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
-
-#define COMP_FUNCTION_TYPE_ARB 0
-#define COMP_FUNCTION_TYPE_NUM 1
-
-#define COMP_FUNCTION_ARB_MASK (1 << 0)
-#define COMP_FUNCTION_MASK     (COMP_FUNCTION_ARB_MASK)
-
-namespace GLFragment {
-
-    class Program {
-	public:
-	    Program () :
-		signature (0),
-		blending (false),
-		name (0),
-		type (GL_FRAGMENT_PROGRAM_ARB)
-	    {};
-	    ~Program ()
-	    {
-		if (name)
-		    (*GL::deletePrograms) (1, &name);
-	    };
-
-	public:
-	    std::vector<FunctionId> signature;
-
-	    bool blending;
-
-	    GLuint name;
-	    GLenum type;
-    };
-
-    typedef enum {
-	OpTypeData,
-	OpTypeDataStore,
-	OpTypeDataOffset,
-	OpTypeDataBlend,
-	OpTypeHeaderTemp,
-	OpTypeHeaderParam,
-	OpTypeHeaderAttrib,
-	OpTypeColor,
-	OpTypeFetch,
-	OpTypeLoad
-    } OpType;
-
-    class HeaderOp {
-	public:
-	    HeaderOp () : type (OpTypeHeaderTemp), name ("") {}
-	public:
-	    OpType     type;
-	    CompString name;
-    };
-
-    class BodyOp {
-	public:
-	    BodyOp () :
-		type (OpTypeData),
-		data (""),
-		dst (""),
-		src (""),
-	        target (0)
-	    {
-		foreach (CompString &str, noOffset)
-		    str = "";
-		foreach (CompString &str, offset)