Merge lp:~amaranth/compiz-core/gles into lp:compiz-core/0.9.5

[Travis Watkins]

This branch contains the code to make compiz work on GLES. This includes several changes to the compiz API.

* GLVertexBuffer class added for managing vertices, normals, texture coordinates, and colors
* GLProgram class added for managing GLSL programs
* GLProgramCache class added for managing per-plugin GLSL programs efficiently, uses an LRU cache
  to avoid recompiling recently used GLSL programs all the time
* GLFragment class removed as fragment programs are no longer used (replaced with GLSL programs)
* GL_BLEND now always enabled when rendering as almost everything was enabling it anyway
* EGL context setup added
* EglTexture class added to use EGL_image extension instead of GLX_EXT_texture_from_pixmap for GLES

Things left to do for a complete port:

  * properly check for GLSL support on desktop, currently assumes if you have VBO support you
    have GLSL support
  * port blur, wobbly, rotate, cube, and water plugins
    * wobbly, cube, and rotate should be fairly straightforward, water and blur need updated to
      use GLSL instead of fragment programs

[Sam Spilsbury (smspillaz)]

1682 + int render (const GLMatrix &modelview,
1683 + const GLWindowPaintAttrib &attrib);
1684 +
1685 + int render (const GLMatrix &projection,
1686 + const GLMatrix &modelview,
1687 + const GLWindowPaintAttrib &attrib);

Probably for the sake of API confusion, it might be worth swapping the order of projection and modelview in this case, so you have

1685 + int render (const GLMatrix &modelview,
1686 + const GLMatrix &projection,
1687 + const GLWindowPaintAttrib &attrib);

--

1586 + GLProgram* operator () (std::list<GLShaderData*>);

Can that take a const std::list <GLShaderData *> & ?

1116 +#if !defined(GL_BGRA)
1117 + #if !defined(GL_BGRA_EXT)
1118 + #error GL_BGRA support is required
1119 + #else
1120 + #define GL_BGRA GL_BGRA_EXT
1121 + #endif
1122 +#endif

This can probably be detected in CMake by using try_compile () [1]

1703 - <default>true</default>
1704 + <default>false</default>

Does this need to be off by default?

1678 + void setProgram (GLProgram *program);
1679 +
1680 + int render (const GLMatrix &modelview);
1681 +
1682 + int render (const GLMatrix &modelview,
1683 + const GLWindowPaintAttrib &attrib);
1684 +
1685 + int render (const GLMatrix &projection,
1686 + const GLMatrix &modelview,
1687 + const GLWindowPaintAttrib &attrib);

The semantics of this are odd. Is GLVertexBuffer meant to be a stateful object which holds on to the state of what its rendering? In that case, it might be more appropriate to have a:

void setProjection ();
void setModelView ();
void setAttrib ();

However, on another though, perhaps all of these arguments are redundant. If glPushMatrix, glLoadMatrixf and glPopMatrix are all parts of the deprecated API, and PrivateGLVertexBuffer::render is really doing this:

+ GLfloat params[4] = {0, 0, 0, 0};
+ GLfloat attribs[3] = {1, 1, 1};
+ GLint index = 0;
+

+ program->setUniform ("projection", projection);
+ program->setUniform ("modelview", modelview);

+ //convert paint attribs to 0-1 range
+ attribs[0] = attrib.opacity / 65535.0f;
+ attribs[1] = attrib.brightness / 65535.0f;
+ attribs[2] = attrib.saturation / 65535.0f;
+ program->setUniform3f ("paintAttrib", attribs[0], attribs[1], attribs[2]);
+

Then it might make more sense to have helper objects in the OpenGL plugin to handle that so that you don't need to pass matrices or paint attributes to the GLVertexBuffer at render time and we don't need to continue to expand the ::render () function argument list should we add more things to the core profile.

The helper object might just server to build a GLProgram with that stuff built in so that it can be passed directly to GLVertexBuffer at render time. Just a thought.

+ #ifdef USE_GLES
+ Display *xdpy = screen->dpy ();
+
+ glFlush ();
+ if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
+ {
+ eglSwapBuffers (eglGetDisplay (xdpy), surface);
+ }
+ else
+ {
+ #warning use proper extension for this
+ eglSwapBuffers (eglGetDisplay (xdpy), surface);
+ }
+ eglW...

[Daniel van Vugt (vanvugt)]

Is there a reason nothing has happened here since Aug/Sep 2011?

Unmerged revisions

2782. By Travis Watkins on 2011-08-10

merge in gles git branch

2781. By Ville Syrjala <email address hidden> on 2011-08-01

[PATCH] Don't unredirect overlay windows until we have set the new
bounding shape for the output window.

Unredirecting them before this time meant that they were stacked
underneath the overlay window and changing the bounding shape of
the output window would cause an expose event to be sent to
the overlay window causing a breif flicker as it redraws.

Unredirecting after this means that no expose event is sent because
the backing store is only set again after the bounding shape of the
output window has been changed

2780. By Sam Spilsbury on 2011-07-29

Merge trunk

2779. By Sam Spilsbury on 2011-07-29

Merge in doc for decor

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2011-07-29 15:08:52 +0000
+++ CMakeLists.txt	2011-08-10 17:09:44 +0000
@@ -103,6 +103,13 @@
     DESTINATION ${COMPIZ_DESTDIR}${libdir}/pkgconfig
 )
 
+# temporarily disable plugins that aren't ported yed
+set (COMPIZ_DISABLE_PLUGIN_BLUR ON)
+set (COMPIZ_DISABLE_PLUGIN_CUBE ON)
+set (COMPIZ_DISABLE_PLUGIN_ROTATE ON)
+set (COMPIZ_DISABLE_PLUGIN_WATER ON)
+set (COMPIZ_DISABLE_PLUGIN_WOBBLY ON)
+
 add_subdirectory (cmake)
 add_subdirectory (include)
 add_subdirectory (images)
@@ -131,4 +138,10 @@
 
 _check_compiz_cmake_macro (${CMAKE_MODULE_PATH_ORIG})
 
+# temporarily disable plugins that aren't ported yed
+SET(COMPIZ_DISABLE_PLUGIN_BLUR "ON")
+SET(COMPIZ_DISABLE_PLUGIN_CUBE "ON")
+SET(COMPIZ_DISABLE_PLUGIN_ROTATE "ON")
+SET(COMPIZ_DISABLE_PLUGIN_WATER "ON")
+SET(COMPIZ_DISABLE_PLUGIN_WOBBLY "ON")
 

=== modified file 'cmake/CMakeLists.txt'
--- cmake/CMakeLists.txt	2011-07-27 16:13:28 +0000
+++ cmake/CMakeLists.txt	2011-08-10 17:09:44 +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	2011-07-27 16:13:28 +0000
+++ cmake/CompizCommon.cmake	2011-08-10 17:09:44 +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	2011-07-13 17:29:00 +0000
+++ cmake/CompizPlugin.cmake	2011-08-10 17:09:44 +0000
@@ -304,6 +304,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")
@@ -316,11 +326,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 (
@@ -334,16 +348,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	2011-08-10 17:09:44 +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	2011-07-27 16:13:28 +0000
+++ cmake/base.cmake	2011-08-10 17:09:44 +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)
@@ -46,7 +47,8 @@
     endif ()
     add_custom_target (findcompiz_install
 	${CMAKE_COMMAND} -E make_directory ${COMPIZ_DESTDIR}${CMAKE_ROOT}/Modules &&
-	${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/cmake/FindCompiz.cmake ${COMPIZ_DESTDIR}${CMAKE_ROOT}/Modules
+	${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/cmake/FindCompiz.cmake ${COMPIZ_DESTDIR}${CMAKE_ROOT}/Modules &&
+	${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/cmake/FindOpenGLES2.cmake ${COMPIZ_DESTDIR}${CMAKE_ROOT}/Modules
     )
 endfunction ()
 

=== added file 'cmake/plugin_extensions/CompizOpenGLFixups.cmake'
--- cmake/plugin_extensions/CompizOpenGLFixups.cmake	1970-01-01 00:00:00 +0000
+++ cmake/plugin_extensions/CompizOpenGLFixups.cmake	2011-08-10 17:09:44 +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/rect.h'
--- include/core/rect.h	2011-03-16 19:39:09 +0000
+++ include/core/rect.h	2011-08-10 17:09:44 +0000
@@ -26,6 +26,8 @@
 #ifndef _COMPRECT_H
 #define _COMPRECT_H
 
+#include <core/point.h>
+
 /**
  * A 2D rectangle, which is likely in screen space. It's data is
  * isolated and can only be mutated with set() methods.

=== modified file 'plugins/annotate/src/annotate.cpp'
--- plugins/annotate/src/annotate.cpp	2010-07-02 03:00:14 +0000
+++ plugins/annotate/src/annotate.cpp	2011-08-10 17:09:44 +0000
@@ -627,11 +627,14 @@
 
     if (status)
     {
+	GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+	GLfloat         vertexData[18];
+	GLfloat         textureData[8];
 	CompRect	rect;
 	GLMatrix	sTransform = transform;
 	int		numRect;
 	int		pos = 0;
-	float		vectorX, vectorY, offset;
+	float		offset;
 	int		angle;
 
 	offset = optionGetStrokeWidth () / 2;
@@ -639,12 +642,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 ())
 	{
 	    foreach (GLTexture *tex, texture)
@@ -654,34 +651,48 @@
 
 	        tex->enable (GLTexture::Fast);
 
-	        glBegin (GL_QUADS);
+	        streamingBuffer->begin (GL_TRIANGLE_STRIP);
 
 	        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 ());
-
+		    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).x2 ();
+		    vertexData[10] = rect.at (pos).y2 ();
+		    vertexData[11] = 0.0f;
+
+		    textureData[0] = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x1 ());
+		    textureData[1] = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y1 ());
+		    textureData[2] = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x1 ());
+		    textureData[3] = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y2 ());
+		    textureData[4] = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x2 ());
+		    textureData[5] = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y1 ());
+		    textureData[6] = COMP_TEX_COORD_X (tex->matrix (),
+		                                       rect.at (pos).x2 ());
+		    textureData[7] = COMP_TEX_COORD_Y (tex->matrix (),
+		                                       rect.at (pos).y2 ());
+
+		    streamingBuffer->addVertices (4, vertexData);
+		    streamingBuffer->addTexCoords (0, 4, textureData);
 	            pos++;
 	        }
 
-	        glEnd ();
+		streamingBuffer->end ();
+		streamingBuffer->render (sTransform);
+
 	        tex->disable ();
 	    }
 	}
@@ -689,85 +700,130 @@
 	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/clone/src/clone.cpp'
--- plugins/clone/src/clone.cpp	2010-02-04 17:16:02 +0000
+++ plugins/clone/src/clone.cpp	2011-08-10 17:09:44 +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	2011-03-14 16:12:45 +0000
+++ plugins/compiztoolbox/src/compiztoolbox.cpp	2011-08-10 17:09:44 +0000
@@ -459,9 +459,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);
@@ -470,9 +468,6 @@
 			      sAttrib.yTranslate / sAttrib.yScale - g.y (),
 			      0.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.getMatrix ());
-
 	filter = gScreen->textureFilter ();
 
 	if (baseScreen->getMipmap ())
@@ -482,13 +477,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);
@@ -529,30 +522,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	2011-08-10 17:09:44 +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/src/cube.cpp'
--- plugins/cube/src/cube.cpp	2011-02-24 07:52:09 +0000
+++ plugins/cube/src/cube.cpp	2011-08-10 17:09:44 +0000
@@ -1123,7 +1123,6 @@
     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
     {
 	priv->gScreen->setTexEnvMode (GL_MODULATE);
-	glEnable (GL_BLEND);
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
@@ -1149,7 +1148,6 @@
     glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
     priv->gScreen->setTexEnvMode (GL_REPLACE);
-    glDisable (GL_BLEND);
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
@@ -1190,7 +1188,6 @@
     if ((priv->mDesktopOpacity != OPAQUE) || (color[3] != OPAQUE))
     {
 	priv->gScreen->setTexEnvMode (GL_MODULATE);
-	glEnable (GL_BLEND);
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
@@ -1206,7 +1203,6 @@
     glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
     priv->gScreen->setTexEnvMode (GL_REPLACE);
-    glDisable (GL_BLEND);
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2011-06-18 06:54:05 +0000
+++ plugins/decor/src/decor.cpp	2011-08-10 17:09:44 +0000
@@ -236,10 +236,10 @@
  */
 
 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;
 
@@ -255,7 +255,7 @@
 	GLTexture::MatrixList ml (1);
 	mask |= PAINT_WINDOW_BLEND_MASK;
 
-	gWindow->geometry ().reset ();
+	gWindow->vertexBuffer ()->begin ();
 
 	for (int i = 0; i < wd->nQuad; i++)
 	{
@@ -271,9 +271,10 @@
 	    }
 	}
 
-	if (gWindow->geometry ().vCount)
-	    gWindow->glDrawTexture (wd->decor->texture->textures[0],
-				    attrib, mask);
+	gWindow->vertexBuffer ()->end ();
+
+	gWindow->glDrawTexture (wd->decor->texture->textures[0], transform,
+	                        attrib, mask);
     }
     else if (wd && !reg.isEmpty () &&
 	     wd->decor->type == WINDOW_DECORATION_TYPE_WINDOW)
@@ -288,11 +289,12 @@
 	if (gWindow->textures ().size () == 1)
 	{
 	    ml[0] = gWindow->matrices ()[0];
-	    gWindow->geometry ().reset ();
+	    gWindow->vertexBuffer ()->begin ();
 	    gWindow->glAddGeometry (ml, window->frameRegion (), reg);
+	    gWindow->vertexBuffer ()->end ();
 
-	    if (gWindow->geometry ().vCount)
-		gWindow->glDrawTexture (gWindow->textures ()[0], attrib, mask);
+	    gWindow->glDrawTexture (gWindow->textures ()[0], transform,
+	                            attrib, mask);
 	}
 	else
 	{
@@ -301,12 +303,12 @@
 	    for (unsigned int i = 0; i < gWindow->textures ().size (); i++)
 	    {
 		ml[0] = gWindow->matrices ()[i];
-		gWindow->geometry ().reset ();
+		gWindow->vertexBuffer ()->begin ();
 		gWindow->glAddGeometry (ml, regions[i], reg);
+		gWindow->vertexBuffer ()->end ();
 
-		if (gWindow->geometry ().vCount)
-		    gWindow->glDrawTexture (gWindow->textures ()[i], attrib,
-					    mask);
+		gWindow->glDrawTexture (gWindow->textures ()[i], transform,
+		                        attrib, mask);
 	    }
 	}
     }

=== modified file 'plugins/decor/src/decor.h'
--- plugins/decor/src/decor.h	2011-05-08 13:44:52 +0000
+++ plugins/decor/src/decor.h	2011-08-10 17:09:44 +0000
@@ -203,7 +203,7 @@
 
 	void computeShadowRegion ();
 
-	bool glDraw (const GLMatrix &, GLFragment::Attrib &,
+	bool glDraw (const GLMatrix &, const GLWindowPaintAttrib &,
 		     const CompRegion &, unsigned int);
 
 	void windowNotify (CompWindowNotify n);

=== modified file 'plugins/imgsvg/src/imgsvg.cpp'
--- plugins/imgsvg/src/imgsvg.cpp	2010-02-04 17:16:02 +0000
+++ plugins/imgsvg/src/imgsvg.cpp	2011-08-10 17:09:44 +0000
@@ -218,12 +218,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;
@@ -249,13 +249,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)
 	    {
@@ -319,11 +321,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	2009-03-15 17:58:48 +0000
+++ plugins/imgsvg/src/imgsvg.h	2011-08-10 17:09:44 +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/obs/src/obs.cpp'
--- plugins/obs/src/obs.cpp	2010-07-02 02:49:24 +0000
+++ plugins/obs/src/obs.cpp	2011-08-10 17:09:44 +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	2010-06-12 07:43:36 +0000
+++ plugins/obs/src/obs.h	2011-08-10 17:09:44 +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	2011-08-10 17:09:44 +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 LIBRARIES ${OPENGLES2_LIBRARIES} INCDIRS ${OPENGLES2_INCLUDE_DIR})
+else (USE_GLES)
+    find_package (OpenGL)
+    if (OPENGL_FOUND)
+	compiz_plugin(opengl PLUGINDEPS composite 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	2011-08-10 17:09:44 +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	2010-04-03 16:24:05 +0000
+++ plugins/opengl/include/opengl/fragment.h	1970-01-01 00:00:00 +0000
@@ -1,124 +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;
-
-/**
- * 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

=== 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	2011-08-10 17:09:44 +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	2011-02-24 07:52:09 +0000
+++ plugins/opengl/include/opengl/opengl.h	2011-08-10 17:09:44 +0000
@@ -28,17 +28,35 @@
 #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 <opengl/matrix.h>
 #include <opengl/texture.h>
-#include <opengl/fragment.h>
+#include <opengl/vertexbuffer.h>
+#include <opengl/program.h>
+#include <opengl/programcache.h>
 
 #define COMPIZ_OPENGL_ABI 3
 
 #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
+
 /**
  * camera distance from screen, 0.5 * tan (FOV)
  */
@@ -75,8 +93,21 @@
 #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);
+
+    #else
     typedef void (*FuncPtr) (void);
+
     typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
 
     typedef void    (*GLXBindTexImageProc)    (Display	 *display,
@@ -121,10 +152,6 @@
     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,
@@ -144,11 +171,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);
@@ -159,6 +191,28 @@
 						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);
+
+    #ifdef USE_GLES
+    extern EGLCreateImageKHRProc  createImage;
+    extern EGLDestroyImageKHRProc destroyImage;
+
+    extern GLEGLImageTargetTexture2DOESProc eglImageTargetTexture;
+
+    #else
     extern GLXBindTexImageProc      bindTexImage;
     extern GLXReleaseTexImageProc   releaseTexImage;
     extern GLXQueryDrawableProc     queryDrawable;
@@ -170,10 +224,6 @@
     extern GLXCreatePixmapProc      createPixmap;
     extern GLXDestroyPixmapProc     destroyPixmap;
 
-    extern GLActiveTextureProc       activeTexture;
-    extern GLClientActiveTextureProc clientActiveTexture;
-    extern GLMultiTexCoord2fProc     multiTexCoord2f;
-
     extern GLGenProgramsProc        genPrograms;
     extern GLDeleteProgramsProc     deletePrograms;
     extern GLBindProgramProc        bindProgram;
@@ -181,6 +231,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;
@@ -189,6 +244,12 @@
     extern GLFramebufferTexture2DProc   framebufferTexture2D;
     extern GLGenerateMipmapProc         generateMipmap;
 
+    extern GLBindBufferProc    bindBuffer;
+    extern GLDeleteBuffersProc deleteBuffers;
+    extern GLGenBuffersProc    genBuffers;
+    extern GLBufferDataProc    bufferData;
+    extern GLBufferSubDataProc bufferSubData;
+
     extern bool  textureFromPixmap;
     extern bool  textureRectangle;
     extern bool  textureNonPowerOfTwo;
@@ -198,6 +259,7 @@
     extern bool  textureCompression;
     extern GLint maxTextureSize;
     extern bool  fbo;
+    extern bool  vbo;
     extern bool  fragmentProgram;
     extern GLint maxTextureUnits;
 
@@ -217,6 +279,7 @@
 
 #define MAX_DEPTH 32
 
+#ifndef USE_GLES
 struct GLFBConfig {
     GLXFBConfig fbConfig;
     int         yInverted;
@@ -224,6 +287,14 @@
     int         textureFormat;
     int         textureTargets;
 };
+#endif
+
+struct GLShaderData
+{
+    std::string name;
+    std::string vertex_shader;
+    std::string fragment_shader;
+};
 
 #define NOTHING_TRANS_FILTER 0
 #define SCREEN_TRANS_FILTER  1
@@ -299,6 +370,8 @@
 					     CompOutput *);
 	virtual void glDisableOutputClipping ();
 
+	virtual GLMatrix *projectionMatrix ();
+
 };
 
 
@@ -329,7 +402,9 @@
 	/**
 	 * Gets the libGL address of a particular openGL functor
 	 */
+	#ifndef USE_GLES
 	GL::FuncPtr getProcAddress (const char *name);
+	#endif
 
 	void updateBackground ();
 
@@ -343,8 +418,6 @@
 	 */
 	void setFilter (int, GLTexture::Filter);
 
-	GLFragment::Storage * fragmentStorage ();
-
 	/**
 	 * Sets a new compiz-wid openGL texture environment mode
 	 */
@@ -368,7 +441,19 @@
 	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<GLShaderData*>);
 
 	/**
 	 * Returns a default icon texture
@@ -377,12 +462,6 @@
 
 	void resetRasterPos ();
 
-	/**
-	 * Returns a 4x4 const float array which
-	 * represents the current projection matrix
-	 */
-	const float * projectionMatrix ();
-
 	WRAPABLE_HND (0, GLScreenInterface, bool, glPaintOutput,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
 		      const CompRegion &, CompOutput *, unsigned int);
@@ -397,6 +476,8 @@
 		      const GLMatrix &, const CompRegion &, CompOutput *);
 	WRAPABLE_HND (4, GLScreenInterface, void, glDisableOutputClipping);
 
+	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
+
 	friend class GLTexture;
 
     private:
@@ -448,10 +529,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
@@ -474,9 +555,8 @@
 				    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 :
@@ -485,40 +565,8 @@
 {
     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);
@@ -561,9 +609,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);
 
@@ -571,14 +630,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;
@@ -588,3 +648,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	2011-08-10 17:09:44 +0000
@@ -0,0 +1,68 @@
+/*
+ * 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);
+
+	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	2011-08-10 17:09:44 +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<GLShaderData*>);
+};
+
+#endif // _COMPIZ_GLPROGRAMCACHE_H
+

=== modified file 'plugins/opengl/include/opengl/texture.h'
--- plugins/opengl/include/opengl/texture.h	2011-02-24 07:52:09 +0000
+++ plugins/opengl/include/opengl/texture.h	2011-08-10 17:09:44 +0000
@@ -30,7 +30,11 @@
 
 #include <X11/Xlib-xcb.h>
 
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
 #include <GL/gl.h>
+#endif
 
 #include <vector>
 

=== 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	2011-08-10 17:09:44 +0000
@@ -0,0 +1,83 @@
+/*
+ * 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_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>
+
+class PrivateVertexBuffer;
+struct GLWindowPaintAttrib;
+
+class GLVertexBuffer
+{
+    public:
+	GLVertexBuffer ();
+	GLVertexBuffer (GLenum usage);
+	~GLVertexBuffer ();
+
+	static GLVertexBuffer *streamingBuffer ();
+
+	void begin (GLenum primitiveType);
+	// default primitiveType is GL_TRIANGLE_STRIP
+	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);
+
+	// texture is index, texcoords are 2 parts, count is number of pairs
+	void addTexCoords (GLuint texture,
+	                   GLuint nTexcoords,
+	                   GLfloat *texcoords);
+
+	void setProgram (GLProgram *program);
+
+	int render (const GLMatrix &modelview);
+
+	int render (const GLMatrix            &modelview,
+	            const GLWindowPaintAttrib &attrib);
+
+	int render (const GLMatrix            &projection,
+	            const GLMatrix            &modelview,
+	            const GLWindowPaintAttrib &attrib);
+
+    private:
+	PrivateVertexBuffer *priv;
+};
+
+#endif // _COMPIZ_GLVERTEXBUFFER_H
+

=== modified file 'plugins/opengl/opengl.xml.in'
--- plugins/opengl/opengl.xml.in	2010-02-03 03:24:09 +0000
+++ plugins/opengl/opengl.xml.in	2011-08-10 17:09:44 +0000
@@ -36,7 +36,7 @@
 	    <option name="sync_to_vblank" type="bool">
 		<_short>Sync To VBlank</_short>
 		<_long>Only perform screen updates during vertical blanking period</_long>
-		<default>true</default>
+		<default>false</default>
 	    </option>
 	    <option name="texture_compression" type="bool">
 		<_short>Texture Compression</_short>

=== removed file 'plugins/opengl/src/fragment.cpp'
--- plugins/opengl/src/fragment.cpp	2010-10-26 03:29:56 +0000
+++ plugins/opengl/src/fragment.cpp	1970-01-01 00:00:00 +0000
@@ -1,1145 +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 <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
-#define foreach BOOST_FOREACH
-
-#include <core/core.h>
-#include <opengl/texture.h>
-#include <opengl/fragment.h>
-#include "privatefragment.h"
-#include "privates.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)
-		    str = "";
-	    };
-
-	public:
-	    OpType       type;
-	    CompString   data;
-	    CompString   dst;
-	    CompString   src;
-	    unsigned int target;
-	    CompString   noOffset[COMP_FETCH_TARGET_NUM];
-	    CompString   offset[COMP_FETCH_TARGET_NUM];
-
-    };
-
-    class PrivateFunctionData {
-	public:
-	    PrivateFunctionData () : header (0), body (0), status (true) {};
-	    PrivateFunctionData (const PrivateFunctionData&, CompString);
-
-	public:
-	    std::vector<HeaderOp> header;
-	    std::vector<BodyOp>   body;
-	    bool                  status;
-    };
-
-    class Function {
-	public:
-	    Function ():
-		id (0),
-		name (""),
-		mask (0)
-	    {};
-
-	public:
-	    FunctionId          id;
-	    CompString          name;
-	    PrivateFunctionData data[COMP_FUNCTION_TYPE_NUM];
-	    unsigned int        mask;
-    };
-
-    class PrivateAttrib {
-	public:
-	    PrivateAttrib () :
-		opacity (0xffff),
-		brightness (0xffff),
-		saturation (0xffff),
-		nTexture (0),
-		nFunction (0),
-		nParam (0)
-	    {}
-
-	    PrivateAttrib (const PrivateAttrib &pa) :
-		opacity (pa.opacity),
-		brightness (pa.brightness),
-		saturation (pa.saturation),
-		nTexture (pa.nTexture),
-		nFunction (pa.nFunction),
-		nParam (pa.nParam)
-	    {
-		for (int i = 0; i < MAX_FRAGMENT_FUNCTIONS; i++)
-		    function[i] = pa.function[i];
-	    }
-
-	public:
-	    GLushort   opacity;
-	    GLushort   brightness;
-	    GLushort   saturation;
-	    int        nTexture;
-	    FunctionId function[MAX_FRAGMENT_FUNCTIONS];
-	    int        nFunction;
-	    int        nParam;
-    };
-
-    typedef boost::function<void (BodyOp *, int)> DataOpCallBack;
-
-    class InitialLoadFunction : public Function {
-	public:
-	    InitialLoadFunction ()
-	    {
-		id   = 0;
-		name = "__core_load";
-		mask = COMP_FUNCTION_MASK;
-
-		BodyOp b;
-		b.type = OpTypeLoad;
-		b.noOffset[0] = "TEX output, fragment.texcoord[0], texture[0], 2D;";
-		b.noOffset[1] = "TEX output, fragment.texcoord[0], texture[0], RECT;";
-		b.offset[0] = "TEX output, __tmp_texcoord0, texture[0], 2D;";
-		b.offset[1] = "TEX output, __tmp_texcoord0, texture[0], RECT;";
-		data[0].body.push_back (b);
-	    };
-    };
-
-    static InitialLoadFunction initialLoadFunction;
-
-    static Function *
-    findFragmentFunction (GLScreen   *s,
-			  FunctionId id)
-    {
-	foreach (Function *f, s->fragmentStorage ()->functions)
-	    if (f->id == id)
-		return f;
-	return NULL;
-    }
-
-    static Function *
-    findFragmentFunctionWithName (GLScreen   *s,
-				  CompString name)
-    {
-	foreach (Function *f, s->fragmentStorage ()->functions)
-	    if (f->name.compare (name) == 0)
-		return f;
-	return NULL;
-    }
-
-    static Program *
-    findFragmentProgram (GLScreen     *s,
-			 FunctionId   *signature,
-			 unsigned int nSignature)
-    {
-	unsigned int i;
-
-	foreach (Program *p, s->fragmentStorage ()->programs)
-	{
-	    if (p->signature.size () != nSignature)
-		continue;
-
-	    for (i = 0; i < nSignature; i++)
-		if (signature[i] != p->signature[i])
-		    break;
-
-	    if (i == nSignature)
-		return p;
-	}
-	return NULL;
-    }
-
-    static unsigned int
-    functionMaskToType (int mask)
-    {
-	static struct {
-	    unsigned int type;
-	    unsigned int mask;
-	} maskToType[] = {
-	    { COMP_FUNCTION_TYPE_ARB, COMP_FUNCTION_ARB_MASK }
-	};
-
-	unsigned int i;
-
-	for (i = 0; i < sizeof (maskToType) / sizeof (maskToType[0]); i++)
-	    if (mask & maskToType[i].mask)
-		return maskToType[i].type;
-
-	return 0;
-    }
-
-    static void
-    forEachDataOpInFunction (std::vector<Function *> list,
-			     int                     index,
-			     int                     type,
-			     int                     loadTarget,
-			     CompString              loadOffset,
-			     bool                    *color,
-			     bool                    *blend,
-			     DataOpCallBack          callBack)
-    {
-	Function *f = list[index];
-	BodyOp   dataOp;
-	bool	 colorDone = false;
-	bool	 blendDone = false;
-
-	*color = false;
-	*blend = false;
-
-	foreach (BodyOp &bodyOp, f->data[type].body)
-	{
-	    switch (bodyOp.type) {
-		case OpTypeFetch: {
-		    CompString offset = loadOffset;
-
-		    /* add offset */
-		    if (bodyOp.data.size ())
-		    {
-			if (loadOffset.size ())
-			{
-			    dataOp.type = OpTypeDataOffset;
-			    dataOp.data =
-				compPrintf ("ADD __tmp_texcoord%d, %s, %s;",
-					    index, loadOffset.c_str (),
-					    bodyOp.data.c_str ());
-
-			    callBack (&dataOp, index);
-
-			    offset = compPrintf ("__tmp_texcoord%d", index);
-			}
-			else
-			{
-			    offset = bodyOp.data;
-			}
-		    }
-
-		    forEachDataOpInFunction (list, index - 1, type,
-					    bodyOp.target,
-					    offset, &colorDone, &blendDone,
-					    callBack);
-
-		    if (bodyOp.dst.compare ("output"))
-		    {
-			dataOp.type = OpTypeDataStore;
-			dataOp.data =
-			    compPrintf ("MOV %s, output;", bodyOp.dst.c_str ());
-
-			/* move to destination */
-			callBack (&dataOp, index);
-		    }
-		} break;
-		case OpTypeLoad:
-		    if (loadOffset.size ())
-		    {
-			dataOp.type = OpTypeDataOffset;
-			dataOp.data =
-			    compPrintf ("ADD __tmp_texcoord0, fragment.texcoord[0], %s;",
-					loadOffset.c_str ());
-
-			callBack (&dataOp, index);
-
-			dataOp.data = bodyOp.offset[loadTarget];
-		    }
-		    else
-		    {
-			dataOp.data = bodyOp.noOffset[loadTarget];
-		    }
-
-		    dataOp.type = OpTypeData;
-
-		    callBack (&dataOp, index);
-
-		    break;
-		case OpTypeColor:
-		    if (!colorDone)
-		    {
-			dataOp.type = OpTypeData;
-			dataOp.data =
-			    compPrintf ("MUL %s, fragment.color, %s;",
-					bodyOp.dst.c_str (),
-					bodyOp.src.c_str ());
-
-			callBack (&dataOp, index);
-		    }
-		    else if (bodyOp.dst.compare (bodyOp.src))
-		    {
-			dataOp.type = OpTypeData;
-			dataOp.data =
-			    compPrintf ("MOV %s, %s;",
-					bodyOp.dst.c_str (),
-					bodyOp.src.c_str ());
-
-			callBack (&dataOp, index);
-		    }
-		    *color = true;
-		    break;
-		case OpTypeDataBlend:
-		    *blend = true;
-		    /* fall-through */
-		case OpTypeData:
-		    callBack (&bodyOp, index);
-		    break;
-		case OpTypeDataStore:
-		case OpTypeDataOffset:
-		case OpTypeHeaderTemp:
-		case OpTypeHeaderParam:
-		case OpTypeHeaderAttrib:
-		    break;
-	    }
-	}
-
-	if (colorDone)
-	    *color = true;
-
-	if (blendDone)
-	    *blend = true;
-    }
-
-    static int
-    forEachHeaderOpWithType (std::vector<HeaderOp> list,
-			     int                   index,
-			     OpType                type,
-			     CompString            prefix,
-			     CompString            functionPrefix,
-			     int                   count,
-			     DataOpCallBack        callBack)
-    {
-	BodyOp dataOp;
-
-	dataOp.type = OpTypeData;
-
-	foreach (HeaderOp &header, list)
-	{
-	    if (header.type == type)
-	    {
-		if (count)
-		{
-		    dataOp.data = ", ";
-		}
-		else
-		{
-		    dataOp.data = prefix;
-		}
-
-		dataOp.data += functionPrefix;
-		dataOp.data += "_";
-		dataOp.data += header.name;
-
-		callBack (&dataOp, index);
-
-		count++;
-	    }
-	}
-
-	return count;
-    }
-
-    static bool
-    forEachDataOp (std::vector<Function *> list,
-		   int                     type,
-		   DataOpCallBack          callBack)
-    {
-	BodyOp dataOp;
-	bool   colorDone;
-	bool   blendDone;
-	int    count, nList = list.size ();
-
-	dataOp.type = OpTypeData;
-
-	count = 1;
-
-	dataOp.data = "TEMP output";
-
-	callBack (&dataOp, nList);
-
-	foreach (Function *f, list)
-	    count = forEachHeaderOpWithType (f->data[type].header,
-					     nList, OpTypeHeaderTemp,
-					     "", f->name, count, callBack);
-
-	dataOp.data = ";";
-
-	callBack (&dataOp, nList);
-
-	count = 0;
-
-	foreach (Function *f, list)
-	    count = forEachHeaderOpWithType (f->data[type].header,
-					     nList, OpTypeHeaderParam,
-					     "PARAM ", f->name, count,
-					     callBack);
-
-	if (count)
-	{
-	    dataOp.data = ";";
-
-	    callBack (&dataOp, nList);
-	}
-
-	count = 0;
-
-	foreach (Function *f, list)
-	    count = forEachHeaderOpWithType (f->data[type].header,
-					     nList, OpTypeHeaderAttrib,
-					     "ATTRIB ", f->name, count,
-					     callBack);
-
-	if (count)
-	{
-	    dataOp.data = ";";
-
-	    callBack (&dataOp, nList);
-	}
-
-	forEachDataOpInFunction (list, nList - 1, type, 0, "",
-				 &colorDone, &blendDone,
-				 callBack);
-
-	if (colorDone)
-	    dataOp.data = "MOV result.color, output;END";
-	else
-	    dataOp.data = "MUL result.color, fragment.color, output;END";
-
-	callBack (&dataOp, nList);
-
-	return blendDone;
-    }
-
-    static void
-    addFetchOffsetVariables (BodyOp     *op,
-			     int	index,
-			     bool       *indices,
-			     CompString *data)
-    {
-	if (op->type == OpTypeDataOffset)
-	{
-	    if (!indices[index])
-	    {
-		data->append (compPrintf ("TEMP __tmp_texcoord%d;", index));
-		indices[index] = true;
-	    }
-	}
-    }
-
-    static void
-    addData (BodyOp     *op,
-	     CompString *data)
-    {
-	data->append (op->data);
-    }
-
-    static Program *
-    buildFragmentProgram (GLScreen      *s,
-			  PrivateAttrib *attrib)
-    {
-	Program	                *program;
-	std::vector<Function *> functionList (1);
-	int                     mask = COMP_FUNCTION_MASK;
-	int                     type;
-	GLint                   errorPos;
-	GLenum			errorType;
-	CompString fetchData;
-	bool       indices[MAX_FRAGMENT_FUNCTIONS];
-	int        i;
-
-	program = new Program ();
-	if (!program)
-	    return NULL;
-
-	functionList[0] = &initialLoadFunction;
-
-	for (i = 0; i < attrib->nFunction; i++)
-	{
-	    Function *f = findFragmentFunction (s, attrib->function[i]);
-
-	    if (f)
-	        functionList.push_back (f);
-	}
-
-	foreach (Function *f, functionList)
-	    mask &= f->mask;
-
-	if (!mask)
-	{
-	    compLogMessage ("opengl", CompLogLevelWarn,
-			    "fragment functions can't be linked together "
-			    "because a common type doesn't exist");
-	}
-
-	if (!mask || functionList.size () == 1)
-	{
-	    delete program;
-	    return NULL;
-	}
-
-	for (i = 0; i < attrib->nFunction; i++)
-	    program->signature.push_back (attrib->function[i]);
-
-	type = functionMaskToType (mask);
-
-	fetchData = "!!ARBfp1.0";
-
-	foreach (bool &val, indices)
-	    val = false;
-
-	forEachDataOp (functionList, type,
-	    boost::bind (addFetchOffsetVariables, _1, _2, indices, &fetchData));
-
-	program->blending = forEachDataOp (functionList, type,
-				boost::bind (addData, _1, &fetchData));
-
-	program->type = GL_FRAGMENT_PROGRAM_ARB;
-
-	glGetError ();
-
-	(*GL::genPrograms) (1, &program->name);
-	(*GL::bindProgram) (GL_FRAGMENT_PROGRAM_ARB, program->name);
-	(*GL::programString) (GL_FRAGMENT_PROGRAM_ARB,
-			      GL_PROGRAM_FORMAT_ASCII_ARB,
-			      fetchData.size (), fetchData.c_str ());
-
-	glGetIntegerv (GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
-	errorType = glGetError ();
-	if (errorType != GL_NO_ERROR || errorPos != -1)
-	{
-	    compLogMessage ("opengl", CompLogLevelError,
-			    "failed to load fragment program");
-
-	    (*GL::deletePrograms) (1, &program->name);
-
-	    program->name = 0;
-	    program->type = 0;
-	}
-
-	return program;
-    }
-
-    static GLuint
-    getFragmentProgram (GLScreen      *s,
-			PrivateAttrib *attrib,
-			GLenum	      *type,
-			bool	      *blending)
-    {
-	Program	*program;
-
-	if (!attrib->nFunction)
-	    return 0;
-
-	program = findFragmentProgram (s, attrib->function, attrib->nFunction);
-	if (!program)
-	{
-	    program = buildFragmentProgram (s, attrib);
-	    if (program)
-	    {
-		s->fragmentStorage ()->programs.push_back (program);
-	    }
-	}
-
-	if (program)
-	{
-	    *type     = program->type;
-	    *blending = program->blending;
-
-	    return program->name;
-	}
-
-	return 0;
-    }
-
-
-    /* performs simple variable substitution */
-    static CompString
-    copyData (std::vector<HeaderOp> header,
-	      const CompString      prefix,
-	      CompString            data)
-    {
-	CompString inPrefix (prefix);
-	inPrefix += "_";
-
-	foreach (HeaderOp &h, header)
-	{
-	    size_t pos = data.find (h.name);
-	    while (pos != std::string::npos)
-	    {
-		bool prependPrefix = false;
-		/* It is possible to match parts of words here, so
-		 * make sure that we have found the next chunk in the
-		 * string and not just a header which matches
-		 * part of another word */
-		if (data.size () > pos + h.name.size ())
-		{
-		    const CompString &token = data.substr (pos + h.name.size (), 1);
-		    if (token == "," ||
-			token == "." ||
-			token == ";")
-		    {
-			prependPrefix = true;
-		    }
-		    else
-		    {
-			/* We matched part of another word as our
-			 * token so search for the next whole
-			 * header op */
-			pos = data.find (h.name, pos + 1);
-		    }
-		}
-		else
-		{
-		    /* If this is the last word in the string, then it must
-		     * have matched exactly our header op, so it is ok
-		     * to prepend a prefix here and go straight to
-		     * std::string::npos */
-		    prependPrefix = true;
-		}
-
-		if (prependPrefix)
-		{
-		    /* prepend the header op prefix to the header op
-		     * and seek past this word to the next instance
-		     * of the unprepended header op */
-		    data.insert (pos, inPrefix);
-		    pos += inPrefix.size () + h.name.size ();
-		    pos = data.find (h.name, pos);
-		}
-	    }
-	}
-
-	return data;
-    }
-
-    PrivateFunctionData::PrivateFunctionData (const PrivateFunctionData& src,
-					      CompString dstPrefix) :
-	header (src.header),
-	body (0),
-	status (src.status)
-    {
-
-	foreach (BodyOp b, src.body)
-	{
-	    BodyOp dst;
-	    dst.type = b.type;
-
-	    switch (b.type) {
-		case OpTypeFetch:
-		    dst.dst = copyData (header, dstPrefix, b.dst);
-		    if (b.data.size ())
-			dst.data = copyData (header, dstPrefix, b.data);
-		    else
-			dst.data = "";
-
-		    dst.target = b.target;
-		    break;
-		case OpTypeLoad:
-		case OpTypeHeaderTemp:
-		case OpTypeHeaderParam:
-		case OpTypeHeaderAttrib:
-		    break;
-		case OpTypeData:
-		case OpTypeDataBlend:
-		case OpTypeDataStore:
-		case OpTypeDataOffset:
-		    dst.data = copyData (header, dstPrefix, b.data);
-		    break;
-		case OpTypeColor:
-		    dst.dst = copyData (header, dstPrefix, b.dst);
-		    dst.src = copyData (header, dstPrefix, b.src);
-		    break;
-		}
-	    body.push_back (dst);
-	}
-    }
-
-    static bool
-    addHeaderOpToFunctionData (PrivateFunctionData *data,
-			       const char          *name,
-			       OpType              type)
-    {
-	static const char *reserved[] = {
-	    "output",
-	    "__tmp_texcoord",
-	    "fragment",
-	    "program",
-	    "result",
-	    "state",
-	    "texture"
-	};
-	HeaderOp   header;
-	CompString n (name);
-
-	foreach (const char *word, reserved)
-	{
-	    if (n.find (word) != std::string::npos)
-	    {
-		compLogMessage ("opengl", CompLogLevelWarn,
-				"%s is a reserved word", word);
-		return false;
-	    }
-	}
-
-
-	header.type = type;
-	header.name = n;
-	data->header.push_back (header);
-
-	return true;
-    }
-
-    FunctionData::FunctionData () :
-	priv (new PrivateFunctionData ())
-    {
-    }
-
-    FunctionData::~FunctionData ()
-    {
-	delete priv;
-    }
-
-    bool
-    FunctionData::status ()
-    {
-	return priv->status;
-    }
-
-    void
-    FunctionData::addTempHeaderOp (const char *name)
-    {
-	priv->status &=
-	    addHeaderOpToFunctionData (priv, name, OpTypeHeaderTemp);
-    }
-
-    void
-    FunctionData::addParamHeaderOp (const char *name)
-    {
-	priv->status &=
-	    addHeaderOpToFunctionData (priv, name, OpTypeHeaderParam);
-    }
-
-    void
-    FunctionData::addAttribHeaderOp (const char *name)
-    {
-	priv->status &=
-	    addHeaderOpToFunctionData (priv, name, OpTypeHeaderAttrib);
-    }
-
-
-    void
-    FunctionData::addFetchOp (const char *dst, const char *offset, int target)
-    {
-	BodyOp b;
-
-	b.type	 = OpTypeFetch;
-	b.dst    = CompString (dst);
-	b.target = target;
-
-	if (offset)
-	    b.data = CompString (offset);
-	else
-	    b.data = CompString ("");
-
-	priv->body.push_back (b);
-    }
-
-    void
-    FunctionData::addColorOp (const char *dst, const char *src)
-    {
-	BodyOp b;
-
-	b.type = OpTypeColor;
-	b.dst  = CompString (dst);
-	b.src  = CompString (src);
-
-	priv->body.push_back (b);
-    }
-
-    void
-    FunctionData::addDataOp (const char *str, ...)
-    {
-	BodyOp  b;
-	va_list ap;
-
-	b.type = OpTypeData;
-	va_start (ap, str);
-	b.data = compPrintf (str, ap);
-	va_end (ap);
-
-	priv->body.push_back (b);
-    }
-
-    void
-    FunctionData::addBlendOp (const char *str, ...)
-    {
-	BodyOp  b;
-	va_list ap;
-
-	b.type = OpTypeDataBlend;
-	va_start (ap, str);
-	b.data = compPrintf (str, ap);
-	va_end (ap);
-
-	priv->body.push_back (b);
-    }
-
-    FunctionId
-    FunctionData::createFragmentFunction (const char *name)
-    {
-	GLScreen     *s = GLScreen::get (screen);
-	Function     *function = new Function ();
-	CompString   validName = name;
-	unsigned int i = 0;
-
-	while (findFragmentFunctionWithName (s, validName))
-	{
-	    validName = compPrintf ("%s%d", name, i++);
-	}
-
-	function->data[COMP_FUNCTION_TYPE_ARB] =
-	    PrivateFunctionData (*priv, validName);
-
-	function->name = validName;
-	function->mask = COMP_FUNCTION_ARB_MASK;
-	function->id   = s->fragmentStorage ()->lastFunctionId++;
-
-	s->fragmentStorage ()->functions.push_back (function);
-
-	return function->id;
-    }
-
-    Attrib::Attrib (const GLWindowPaintAttrib &paint) :
-	priv (new PrivateAttrib ())
-    {
-	priv->opacity    = paint.opacity;
-	priv->brightness = paint.brightness;
-	priv->saturation = paint.saturation;
-	priv->nTexture   = 0;
-	priv->nFunction  = 0;
-	priv->nParam     = 0;
-
-	foreach (FunctionId &f, priv->function)
-	    f = 0;
-    }
-
-    Attrib::Attrib (const Attrib &fa) :
-	priv (new PrivateAttrib (*fa.priv))
-    {
-    }
-
-    Attrib::~Attrib ()
-    {
-	delete priv;
-    }
-
-    Attrib &
-    Attrib::operator= (const Attrib &rhs)
-    {
-	if (this == &rhs) // Check for self-assignment
-	    return *this;
-
-	delete priv;
-	priv = new PrivateAttrib (*rhs.priv);
-
-	return *this;
-    }
-
-    unsigned int
-    Attrib::allocTextureUnits (unsigned int nTexture)
-    {
-	unsigned int first = priv->nTexture;
-
-	priv->nTexture += nTexture;
-
-	/* 0 is reserved for source texture */
-	return 1 + first;
-    }
-
-    unsigned int
-    Attrib::allocParameters (unsigned int nParam)
-    {
-	unsigned int first = priv->nParam;
-
-	priv->nParam += nParam;
-
-	return first;
-    }
-
-    void
-    Attrib::addFunction (FunctionId function)
-    {
-	if (priv->nFunction < MAX_FRAGMENT_FUNCTIONS)
-	    priv->function[priv->nFunction++] = function;
-    }
-
-    bool
-    Attrib::enable (bool *blending)
-    {
-	GLuint name;
-	GLenum type;
-	bool   programBlending;
-
-	if (!GL::fragmentProgram)
-	    return false;
-
-	name = getFragmentProgram (GLScreen::get (screen), priv, &type,
-				   &programBlending);
-	if (!name)
-	    return false;
-
-	*blending = !programBlending;
-
-	glEnable (GL_FRAGMENT_PROGRAM_ARB);
-
-	(*GL::bindProgram) (type, name);
-
-	return true;
-    }
-
-    void
-    Attrib::disable ()
-    {
-	glDisable (GL_FRAGMENT_PROGRAM_ARB);
-    }
-
-    unsigned short
-    Attrib::getSaturation ()
-    {
-	return priv->saturation;
-    }
-
-    unsigned short
-    Attrib::getBrightness ()
-    {
-	return priv->brightness;
-    }
-
-    unsigned short
-    Attrib::getOpacity ()
-    {
-	return priv->opacity;
-    }
-
-    void
-    Attrib::setSaturation (unsigned short value)
-    {
-	priv->saturation = value;
-    }
-
-    void
-    Attrib::setBrightness (unsigned short value)
-        {
-	priv->brightness = value;
-    }
-
-
-    void
-    Attrib::setOpacity (unsigned short value)
-    {
-	priv->opacity = value;
-    }
-
-    bool
-    Attrib::hasFunctions ()
-    {
-	return priv->nFunction > 0;
-    }
-
-    void destroyFragmentFunction (FunctionId id)
-    {
-	GLScreen *s = GLScreen::get (screen);
-	Function *function;
-	Program  *program;
-
-	function = findFragmentFunction (s, id);
-
-	if (!function)
-	    return;
-
-	std::vector<Program *>::iterator it;
-
-	do {
-	    program = NULL;
-
-	    it = s->fragmentStorage ()->programs.begin ();
-
-	    for (; it != s->fragmentStorage ()->programs.end (); it++)
-	    {
-		foreach (FunctionId i, (*it)->signature)
-		    if (i == id)
-		    {
-			program = (*it);
-			break;
-		    }
-
-		if (program)
-		    break;
-	    }
-
-	    if (program)
-	    {
-		delete program;
-		s->fragmentStorage ()->programs.erase (it);
-	    }
-
-	} while (program);
-
-	std::vector<Function *>::iterator fi =
-	    std::find (s->fragmentStorage ()->functions.begin (),
-		       s->fragmentStorage ()->functions.end (),
-		       function);
-	if (fi != s->fragmentStorage ()->functions.end ())
-	    s->fragmentStorage ()->functions.erase (fi);
-
-	delete (function);
-    }
-
-    FunctionId
-    getSaturateFragmentFunction (GLTexture *texture,
-				 int         param)
-    {
-	int      target;
-	GLScreen *s = GLScreen::get (screen);
-
-	if (param >= 64)
-	    return 0;
-
-	if (texture->target () == GL_TEXTURE_2D)
-	    target = COMP_FETCH_TARGET_2D;
-	else
-	    target = COMP_FETCH_TARGET_RECT;
-
-	if (!s->fragmentStorage ()->saturateFunction [target][param])
-	{
-	    static const char *saturateData =
-		"MUL temp, output, { 1.0, 1.0, 1.0, 0.0 };"
-		"DP3 temp, temp, program.env[%d];"
-		"LRP output.xyz, program.env[%d].w, output, temp;";
-	    FunctionData  data;
-
-	    data.addTempHeaderOp ("temp");
-	    data.addFetchOp ("output", NULL, target);
-	    data.addColorOp ("output", "output");
-
-	    data.addDataOp (saturateData, param, param);
-
-	    if (!data.status ())
-		return 0;
-
-	    s->fragmentStorage ()->saturateFunction [target][param] =
-		data.createFragmentFunction ("__core_saturate");
-
-	}
-
-	return s->fragmentStorage ()->saturateFunction [target][param];
-    }
-
-    Storage::Storage () :
-	lastFunctionId (1),
-	functions (0),
-	programs (0)
-    {
-	for (int i = 0; i < 64; i++)
-	{
-	    saturateFunction[0][i] = 0;
-	    saturateFunction[1][i] = 0;
-	}
-    }
-
-    Storage::~Storage ()
-    {
-	foreach (Program *p, programs)
-	    delete p;
-	programs.clear ();
-	foreach (Function *f, functions)
-	    delete f;
-	functions.clear ();
-    }
-
-};

=== modified file 'plugins/opengl/src/matrix.cpp'
--- plugins/opengl/src/matrix.cpp	2010-10-24 14:42:07 +0000
+++ plugins/opengl/src/matrix.cpp	2011-08-10 17:09:44 +0000
@@ -159,6 +159,60 @@
 #undef B
 #undef P
 
+/*
+** Invert 4x4 matrix.
+** Contributed by David Moore (See Mesa bug #6748)
+*/
+bool GLMatrix::invert ()
+{
+    float inv[16], det;
+    int i;
+
+    inv[0] =   m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
+             + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
+    inv[4] =  -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
+             - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
+    inv[8] =   m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
+             + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
+    inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
+             - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
+    inv[1] =  -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
+             - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
+    inv[5] =   m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
+             + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
+    inv[9] =  -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
+             - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
+    inv[13] =  m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
+             + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
+    inv[2] =   m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
+             + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
+    inv[6] =  -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
+             - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
+    inv[10] =  m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
+             + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
+    inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
+             - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
+    inv[3] =  -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
+             - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
+    inv[7] =   m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
+             + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
+    inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
+             - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
+    inv[15] =  m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
+             + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
+
+    det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
+    if (det == 0)
+        return false;
+
+    det = 1.0f / det;
+
+    for (i = 0; i < 16; i++)
+        m[i] = inv[i] * det;
+
+    return true;
+}
+
 /**
  * Generate a 4x4 transformation matrix from glRotate parameters, and
  * post-multiply the input matrix by it.

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2011-05-07 08:58:54 +0000
+++ plugins/opengl/src/paint.cpp	2011-08-10 17:09:44 +0000
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2005 Novell, Inc.
+ * Copyright © 2011 Linaro, Ltd.
  *
  * Permission to use, copy, modify, distribute, and sell this software
  * and its documentation for any purpose is hereby granted without
@@ -20,7 +21,8 @@
  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  *
- * Author: David Reveman <[e-mail]>
+ * Authors: David Reveman <[e-mail]>
+ *          Travis Watkins <[e-mail]>
  */
 
 #include <stdlib.h>
@@ -34,6 +36,7 @@
 #include <opengl/opengl.h>
 
 #include "privates.h"
+#include "shaders.h"
 
 
 GLScreenPaintAttrib defaultScreenPaintAttrib = {
@@ -63,12 +66,16 @@
 }
 
 void
-PrivateGLScreen::paintBackground (const CompRegion &region,
-				  bool             transformed)
+PrivateGLScreen::paintBackground (const GLMatrix   &transform,
+                                  const CompRegion &region,
+                                  bool             transformed)
 {
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+    GLfloat         vertexData[16];
+    GLushort        colorData[4];
+
     BoxPtr    pBox = const_cast <Region> (region.handle ())->rects;
     int	      n, nBox = const_cast <Region> (region.handle ())->numRects;
-    GLfloat   *d, *data;
 
     if (!nBox)
 	return;
@@ -92,81 +99,83 @@
 	backgroundLoaded = true;
     }
 
-    data = new GLfloat [nBox * 16];
-    if (!data)
-	return;
-
-    d = data;
     n = nBox;
 
     if (backgroundTextures.empty ())
     {
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
 	while (n--)
 	{
-	    *d++ = pBox->x1;
-	    *d++ = pBox->y2;
-
-	    *d++ = pBox->x2;
-	    *d++ = pBox->y2;
-
-	    *d++ = pBox->x2;
-	    *d++ = pBox->y1;
-
-	    *d++ = pBox->x1;
-	    *d++ = pBox->y1;
+	    vertexData[0]  = pBox->x1;
+	    vertexData[1]  = pBox->y1;
+	    vertexData[2]  = 0.0f;
+	    vertexData[3]  = pBox->x1;
+	    vertexData[4]  = pBox->y2;
+	    vertexData[5]  = 0.0f;
+	    vertexData[6]  = pBox->x2;
+	    vertexData[7]  = pBox->y1;
+	    vertexData[8]  = 0.0f;
+	    vertexData[9]  = pBox->x2;
+	    vertexData[10] = pBox->y2;
+	    vertexData[11] = 0.0f;
+
+	    streamingBuffer->addVertices (4, vertexData);
 
 	    pBox++;
 	}
 
-	glVertexPointer (2, GL_FLOAT, sizeof (GLfloat) * 2, data + 2);
+	colorData[0] = colorData[1] = colorData[2] = colorData[3] = 0;
+	streamingBuffer->addColors (1, colorData);
 
-	glColor4us (0, 0, 0, 0);
-	glDrawArrays (GL_QUADS, 0, nBox * 4);
-	glColor4usv (defaultColor);
+	streamingBuffer->end ();
+	streamingBuffer->render (transform);
     }
     else
     {
 	for (unsigned int i = 0; i < backgroundTextures.size (); i++)
 	{
+	    GLfloat textureData[8];
 	    GLTexture *bg = backgroundTextures[i];
 	    CompRegion r = region & *bg;
 
 	    pBox = const_cast <Region> (r.handle ())->rects;
 	    nBox = const_cast <Region> (r.handle ())->numRects;
-	    d = data;
 	    n = nBox;
 
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
 	    while (n--)
 	    {
-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y2);
-
-		*d++ = pBox->x1;
-		*d++ = pBox->y2;
-
-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y2);
-
-		*d++ = pBox->x2;
-		*d++ = pBox->y2;
-
-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y1);
-
-		*d++ = pBox->x2;
-		*d++ = pBox->y1;
-
-		*d++ = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
-		*d++ = COMP_TEX_COORD_Y (bg->matrix (), pBox->y1);
-
-		*d++ = pBox->x1;
-		*d++ = pBox->y1;
+		vertexData[0]  = pBox->x1;
+		vertexData[1]  = pBox->y1;
+		vertexData[2]  = 0.0f;
+		vertexData[3]  = pBox->x1;
+		vertexData[4]  = pBox->y2;
+		vertexData[5]  = 0.0f;
+		vertexData[6]  = pBox->x2;
+		vertexData[7]  = pBox->y1;
+		vertexData[8]  = 0.0f;
+		vertexData[9]  = pBox->x2;
+		vertexData[10] = pBox->y2;
+		vertexData[11] = 0.0f;
+
+		textureData[0] = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
+		textureData[1] = COMP_TEX_COORD_X (bg->matrix (), pBox->y1);
+		textureData[2] = COMP_TEX_COORD_X (bg->matrix (), pBox->x1);
+		textureData[3] = COMP_TEX_COORD_X (bg->matrix (), pBox->y2);
+		textureData[4] = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
+		textureData[5] = COMP_TEX_COORD_X (bg->matrix (), pBox->y1);
+		textureData[6] = COMP_TEX_COORD_X (bg->matrix (), pBox->x2);
+		textureData[7] = COMP_TEX_COORD_X (bg->matrix (), pBox->y2);
+
+		streamingBuffer->addVertices (4, vertexData);
+		streamingBuffer->addTexCoords (0, 4, textureData);
 
 		pBox++;
 	    }
 
-	    glTexCoordPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, data);
-	    glVertexPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, data + 2);
+	    streamingBuffer->end ();
 
 	    if (bg->name ())
 	    {
@@ -175,14 +184,12 @@
 		else
 		    bg->enable (GLTexture::Fast);
 
-		glDrawArrays (GL_QUADS, 0, nBox * 4);
+		streamingBuffer->render (transform);
 
 		bg->disable ();
 	    }
 	}
     }
-
-    delete [] data;
 }
 
 
@@ -309,7 +316,9 @@
 	CompositeWindow::get (fullscreenWindow)->unredirect ();
 
     if (!(mask & PAINT_SCREEN_NO_BACKGROUND_MASK))
-	paintBackground (tmpRegion, (mask & PAINT_SCREEN_TRANSFORMED_MASK));
+	paintBackground (transform,
+	                 tmpRegion,
+	                 (mask & PAINT_SCREEN_TRANSFORMED_MASK));
 
     /* paint all windows from bottom to top */
     foreach (w, pl)
@@ -358,6 +367,7 @@
 {
     WRAPABLE_HND_FUNC (3, glEnableOutputClipping, transform, region, output)
 
+    #ifndef USE_GLES
     GLdouble h = screen->height ();
 
     GLdouble p1[2] = { static_cast<GLdouble> (region.handle ()->extents.x1),
@@ -390,6 +400,7 @@
     glEnable (GL_CLIP_PLANE3);
 
     glPopMatrix ();
+    #endif
 }
 
 void
@@ -397,10 +408,12 @@
 {
     WRAPABLE_HND_FUNC (4, glDisableOutputClipping)
 
+    #ifndef USE_GLES
     glDisable (GL_CLIP_PLANE0);
     glDisable (GL_CLIP_PLANE1);
     glDisable (GL_CLIP_PLANE2);
     glDisable (GL_CLIP_PLANE3);
+    #endif
 }
 
 #define CLIP_PLANE_MASK (PAINT_SCREEN_TRANSFORMED_MASK | \
@@ -430,26 +443,14 @@
 	glEnableOutputClipping (sTransform, region, output);
 
 	sTransform.toScreenSpace (output, -sAttrib.zTranslate);
-
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
 	priv->paintOutputRegion (sTransform, region, output, mask);
 
-	glPopMatrix ();
-
 	glDisableOutputClipping ();
     }
     else
     {
 	sTransform.toScreenSpace (output, -sAttrib.zTranslate);
-
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
 	priv->paintOutputRegion (sTransform, region, output, mask);
-
-	glPopMatrix ();
     }
 }
 
@@ -484,13 +485,8 @@
 
 	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
 	priv->paintOutputRegion (sTransform, region, output, mask);
 
-	glPopMatrix ();
-
 	return true;
     }
     else if (mask & PAINT_SCREEN_FULL_MASK)
@@ -506,182 +502,172 @@
     }
 }
 
-#define ADD_RECT(data, m, n, x1, y1, x2, y2)	   \
-    for (it = 0; it < n; it++)			   \
-    {						   \
-        const GLTexture::Matrix &mat = m[it];	   \
-	*(data)++ = COMP_TEX_COORD_X (mat, x1);    \
-	*(data)++ = COMP_TEX_COORD_Y (mat, y1);    \
-    }						   \
-    *(data)++ = (x1);				   \
-    *(data)++ = (y1);				   \
-    *(data)++ = 0.0;				   \
-    for (it = 0; it < n; it++)			   \
-    {						   \
-        const GLTexture::Matrix &mat = m[it];	   \
-	*(data)++ = COMP_TEX_COORD_X (mat, x1);    \
-	*(data)++ = COMP_TEX_COORD_Y (mat, y2);    \
-    }						   \
-    *(data)++ = (x1);				   \
-    *(data)++ = (y2);				   \
-    *(data)++ = 0.0;				   \
-    for (it = 0; it < n; it++)			   \
-    {						   \
-        const GLTexture::Matrix &mat = m[it];	   \
-	*(data)++ = COMP_TEX_COORD_X (mat, x2);    \
-	*(data)++ = COMP_TEX_COORD_Y (mat, y2);    \
-    }						   \
-    *(data)++ = (x2);				   \
-    *(data)++ = (y2);				   \
-    *(data)++ = 0.0;				   \
-    for (it = 0; it < n; it++)			   \
-    {						   \
-        const GLTexture::Matrix &mat = m[it];	   \
-	*(data)++ = COMP_TEX_COORD_X (mat, x2);    \
-	*(data)++ = COMP_TEX_COORD_Y (mat, y1);    \
-    }						   \
-    *(data)++ = (x2);				   \
-    *(data)++ = (y1);				   \
-    *(data)++ = 0.0
-
-#define ADD_QUAD(data, m, n, x1, y1, x2, y2)		\
-    for (it = 0; it < n; it++)				\
-    {							\
-        const GLTexture::Matrix &mat = m[it];		\
-	*(data)++ = COMP_TEX_COORD_XY (mat, x1, y1);	\
-	*(data)++ = COMP_TEX_COORD_YX (mat, x1, y1);	\
-    }							\
-    *(data)++ = (x1);					\
-    *(data)++ = (y1);					\
-    *(data)++ = 0.0;					\
-    for (it = 0; it < n; it++)				\
-    {							\
-        const GLTexture::Matrix &mat = m[it];		\
-	*(data)++ = COMP_TEX_COORD_XY (mat, x1, y2);	\
-	*(data)++ = COMP_TEX_COORD_YX (mat, x1, y2);	\
-    }							\
-    *(data)++ = (x1);					\
-    *(data)++ = (y2);					\
-    *(data)++ = 0.0;					\
-    for (it = 0; it < n; it++)				\
-    {							\
-        const GLTexture::Matrix &mat = m[it];	        \
-	*(data)++ = COMP_TEX_COORD_XY (mat, x2, y2);	\
-	*(data)++ = COMP_TEX_COORD_YX (mat, x2, y2);	\
-    }							\
-    *(data)++ = (x2);					\
-    *(data)++ = (y2);					\
-    *(data)++ = 0.0;					\
-    for (it = 0; it < n; it++)				\
-    {							\
-        const GLTexture::Matrix &mat = m[it];	        \
-	*(data)++ = COMP_TEX_COORD_XY (mat, x2, y1);	\
-	*(data)++ = COMP_TEX_COORD_YX (mat, x2, y1);	\
-    }							\
-    *(data)++ = (x2);					\
-    *(data)++ = (y1);					\
-    *(data)++ = 0.0;
-
-void
-GLWindow::glDrawGeometry ()
-{
-    WRAPABLE_HND_FUNC (4, glDrawGeometry)
-
-    int     texUnit = priv->geometry.texUnits;
-    int     currentTexUnit = 0;
-    int     stride = priv->geometry.vertexStride;
-    GLfloat *vertices = priv->geometry.vertices + (stride - 3);
-
-    stride *= sizeof (GLfloat);
-
-    glVertexPointer (3, GL_FLOAT, stride, vertices);
-
-    while (texUnit--)
-    {
-	if (texUnit != currentTexUnit)
-	{
-	    (*GL::clientActiveTexture) (GL_TEXTURE0_ARB + texUnit);
-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-	    currentTexUnit = texUnit;
-	}
-	vertices -= priv->geometry.texCoordSize;
-	glTexCoordPointer (priv->geometry.texCoordSize,
-			   GL_FLOAT, stride, vertices);
-    }
-
-    glDrawArrays (GL_QUADS, 0, priv->geometry.vCount);
-
-    /* disable all texture coordinate arrays except 0 */
-    texUnit = priv->geometry.texUnits;
-    if (texUnit > 1)
-    {
-	while (--texUnit)
-	{
-	    (*GL::clientActiveTexture) (GL_TEXTURE0_ARB + texUnit);
-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-	}
-
-	(*GL::clientActiveTexture) (GL_TEXTURE0_ARB);
-    }
-}
+#define ADD_RECT(vertexBuffer, m, n, x1, y1, x2, y2) \
+    GLfloat vertexData[18] = {                       \
+	x1, y1, 0.0,                                 \
+	x1, y2, 0.0,                                 \
+	x2, y1, 0.0,                                 \
+	x2, y1, 0.0,                                 \
+	x1, y2, 0.0,                                 \
+	x2, y2, 0.0                                  \
+    };                                               \
+    vertexBuffer->addVertices (6, vertexData);       \
+                                                     \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x1);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x1);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x2);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x2);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y1);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x1);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_X (mat, x2);        \
+	data[1] = COMP_TEX_COORD_Y (mat, y2);        \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }
+
+#define ADD_QUAD(vertexBuffer, m, n, x1, y1, x2, y2) \
+    GLfloat vertexData[18] = {                       \
+	x1, y1, 0.0,                                 \
+	x1, y2, 0.0,                                 \
+	x2, y1, 0.0,                                 \
+	x2, y1, 0.0,                                 \
+	x1, y2, 0.0,                                 \
+	x2, y2, 0.0                                  \
+    };                                               \
+    vertexBuffer->addVertices (6, vertexData);       \
+                                                     \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x1, y1);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x1, y1);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x1, y2);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x1, y2);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x2, y1);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x2, y1);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x2, y1);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x2, y1);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x1, y2);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x1, y2);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }                                                \
+    for (it = 0; it < n; it++)                       \
+    {                                                \
+	GLfloat data[2];                             \
+	const GLTexture::Matrix &mat = m[it];        \
+	data[0] = COMP_TEX_COORD_XY (mat, x2, y2);   \
+	data[1] = COMP_TEX_COORD_YX (mat, x2, y2);   \
+	vertexBuffer->addTexCoords (it, 1, data);    \
+    }
+
 
 static inline void
-addSingleQuad (GLfloat      *&d,
-	       const        GLTexture::MatrixList &matrix,
-	       unsigned int nMatrix,
-	       int          x1,
-	       int          y1,
-	       int          x2,
-	       int          y2,
-	       int          &n,
-	       bool         rect)
+addSingleQuad (GLVertexBuffer *vertexBuffer,
+               const GLTexture::MatrixList &matrix,
+               unsigned int nMatrix,
+               int          x1,
+               int          y1,
+               int          x2,
+               int          y2,
+               int          &n,
+               bool         rect)
 {
     unsigned int it;
 
     if (rect)
     {
-	ADD_RECT (d, matrix, nMatrix, x1, y1, x2, y2);
+	ADD_RECT (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2);
     }
     else
     {
-	ADD_QUAD (d, matrix, nMatrix, x1, y1, x2, y2);
+	ADD_QUAD (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2);
     }
     n++;
 }
 
 static inline void
-addQuads (GLfloat      *&d,
-	  const        GLTexture::MatrixList &matrix,
-	  unsigned int nMatrix,
-	  int          x1,
-	  int          y1,
-	  int          x2,
-	  int          y2,
-	  int          &n,
-	  int          vSize,
-	  bool         rect,
-	  GLWindow::Geometry &geometry,
-	  unsigned int maxGridWidth,
-	  unsigned int maxGridHeight)
+addQuads (GLVertexBuffer *vertexBuffer,
+          const GLTexture::MatrixList &matrix,
+          unsigned int nMatrix,
+          int          x1,
+          int          y1,
+          int          x2,
+          int          y2,
+          int          &n,
+          bool         rect,
+          unsigned int maxGridWidth,
+          unsigned int maxGridHeight)
 {
     int nQuadsX = (maxGridWidth == MAXSHORT) ? 1 :
 	1 + (x2 - x1 - 1) / (int) maxGridWidth;  // ceil. division
     int nQuadsY = (maxGridHeight == MAXSHORT) ? 1 :
 	1 + (y2 - y1 - 1) / (int) maxGridHeight;
-    int newVertexSize = (n + nQuadsX * nQuadsY) * vSize * 4;
-
-    // Make sure enough vertices are allocated for nQuadsX * nQuadsY more quads
-    if (newVertexSize > geometry.vertexSize)
-    {
-	if (!geometry.moreVertices (newVertexSize))
-	    return;
-
-	d = geometry.vertices + (n * vSize * 4);
-    }
 
     if (nQuadsX == 1 && nQuadsY == 1)
     {
-	addSingleQuad (d, matrix, nMatrix, x1, y1, x2, y2, n, rect);
+	addSingleQuad (vertexBuffer, matrix, nMatrix, x1, y1, x2, y2, n, rect);
     }
     else
     {
@@ -697,7 +683,8 @@
 	    {
 		nx2 = MIN (nx1 + (int) quadWidth, x2);
 
-		addSingleQuad (d, matrix, nMatrix, nx1, ny1, nx2, ny2, n, rect);
+		addSingleQuad (vertexBuffer, matrix, nMatrix,
+		               nx1, ny1, nx2, ny2, n, rect);
 	    }
 	}
     }
@@ -715,8 +702,6 @@
     BoxRec full;
     int    nMatrix = matrix.size ();
 
-    priv->geometry.texUnits = nMatrix;
-
     full = clip.handle ()->extents;
     if (region.handle ()->extents.x1 > full.x1)
 	full.x1 = region.handle ()->extents.x1;
@@ -734,9 +719,7 @@
 	BoxPtr  pClip;
 	int     nClip;
 	BoxRec  cbox;
-	int     vSize;
 	int     n, it, x1, y1, x2, y2;
-	GLfloat *d;
 	bool    rect = true;
 
 	for (it = 0; it < nMatrix; it++)
@@ -751,18 +734,6 @@
 	pBox = const_cast <Region> (region.handle ())->rects;
 	nBox = const_cast <Region> (region.handle ())->numRects;
 
-	vSize = 3 + nMatrix * 2;
-
-	n = priv->geometry.vCount / 4;
-
-	if ((n + nBox) * vSize * 4 > priv->geometry.vertexSize)
-	{
-	    if (!priv->geometry.moreVertices ((n + nBox) * vSize * 4))
-		return;
-	}
-
-	d = priv->geometry.vertices + (priv->geometry.vCount * vSize);
-
 	while (nBox--)
 	{
 	    x1 = pBox->x1;
@@ -787,24 +758,15 @@
 
 		if (nClip == 1)
 		{
-		    addQuads (d, matrix, nMatrix,
+		    addQuads (priv->vertexBuffer, matrix, nMatrix,
 			      x1, y1, x2, y2,
-			      n, vSize, rect, priv->geometry,
+			      n, rect,
 			      maxGridWidth, maxGridHeight);
 		}
 		else
 		{
 		    pClip = const_cast <Region> (clip.handle ())->rects;
 
-		    if (((n + nClip) * vSize * 4) > priv->geometry.vertexSize)
-		    {
-			if (!priv->geometry.moreVertices ((n + nClip) *
-							  vSize * 4))
-			    return;
-
-			d = priv->geometry.vertices + (n * vSize * 4);
-		    }
-
 		    while (nClip--)
 		    {
 			cbox = *pClip;
@@ -822,120 +784,32 @@
 
 			if (cbox.x1 < cbox.x2 && cbox.y1 < cbox.y2)
 			{
-			    addQuads (d, matrix, nMatrix,
+			    addQuads (priv->vertexBuffer, matrix, nMatrix,
 				      cbox.x1, cbox.y1, cbox.x2, cbox.y2,
-				      n, vSize, rect, priv->geometry,
+				      n, rect,
 				      maxGridWidth, maxGridHeight);
 			}
 		    }
 		}
 	    }
 	}
-
-	priv->geometry.vCount       = n * 4;
-	priv->geometry.vertexStride = vSize;
-	priv->geometry.texCoordSize = 2;
-    }
-}
-
-static bool
-enableFragmentProgramAndDrawGeometry (GLScreen	         *gs,
-				      GLWindow           *w,
-				      GLTexture          *texture,
-				      GLFragment::Attrib &attrib,
-				      GLTexture::Filter  filter,
-				      unsigned int       mask)
-{
-    GLFragment::Attrib fa (attrib);
-    bool               blending;
-
-    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
-    {
-	int param, function;
-
-	param    = fa.allocParameters (1);
-	function =
-	    GLFragment::getSaturateFragmentFunction (texture, param);
-
-	fa.addFunction (function);
-
-	(*GL::programEnvParameter4f) (GL_FRAGMENT_PROGRAM_ARB, param,
-				      RED_SATURATION_WEIGHT,
-				      GREEN_SATURATION_WEIGHT,
-				      BLUE_SATURATION_WEIGHT,
-				      attrib.getSaturation () / 65535.0f);
-    }
-
-    if (!fa.enable (&blending))
-	return false;
-
-    texture->enable (filter);
-
-    if (mask & PAINT_WINDOW_BLEND_MASK)
-    {
-	if (blending)
-	    glEnable (GL_BLEND);
-
-	if (attrib.getOpacity () != OPAQUE || attrib.getBrightness () != BRIGHT)
-	{
-	    GLushort color;
-
-	    color = (attrib.getOpacity () * attrib.getBrightness ()) >> 16;
-
-	    gs->setTexEnvMode (GL_MODULATE);
-	    glColor4us (color, color, color, attrib.getOpacity ());
-
-	    w->glDrawGeometry ();
-
-	    glColor4usv (defaultColor);
-	    gs->setTexEnvMode (GL_REPLACE);
-	}
-	else
-	{
-	    w->glDrawGeometry ();
-	}
-
-	if (blending)
-	    glDisable (GL_BLEND);
-    }
-    else if (attrib.getBrightness () != BRIGHT)
-    {
-	gs->setTexEnvMode (GL_MODULATE);
-	glColor4us (attrib.getBrightness (), attrib.getBrightness (),
-		    attrib.getBrightness (), BRIGHT);
-
-	w->glDrawGeometry ();
-
-	glColor4usv (defaultColor);
-	gs->setTexEnvMode (GL_REPLACE);
-    }
-    else
-    {
-	w->glDrawGeometry ();
-    }
-
-    texture->disable ();
-
-    fa.disable ();
-
-    return true;
-}
-
+    }
+}
+
+#ifndef USE_GLES
 static void
-enableFragmentOperationsAndDrawGeometry (GLScreen	    *gs,
-					 GLWindow	    *w,
-					 GLTexture	    *texture,
-					 GLFragment::Attrib &attrib,
-					 GLTexture::Filter  filter,
-					 unsigned int	    mask)
+enableLegacyOBSAndRender (GLScreen                  *gs,
+                          GLWindow                  *w,
+                          GLTexture                 *texture,
+                          const GLMatrix            &transform,
+                          const GLWindowPaintAttrib &attrib,
+                          GLTexture::Filter         filter,
+                          unsigned int              mask)
 {
-    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
+    if (GL::canDoSaturated && attrib.saturation != COLOR)
     {
 	GLfloat constant[4];
 
-	if (mask & PAINT_WINDOW_BLEND_MASK)
-	    glEnable (GL_BLEND);
-
 	texture->enable (filter);
 
 	glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
@@ -966,7 +840,7 @@
 	glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
 	glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
 
-	if (GL::canDoSlightlySaturated && attrib.getSaturation () > 0)
+	if (GL::canDoSlightlySaturated && attrib.saturation > 0)
 	{
 	    glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
 	    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
@@ -997,20 +871,20 @@
 	    glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
 
-	    constant[3] = attrib.getSaturation () / 65535.0f;
+	    constant[3] = attrib.saturation / 65535.0f;
 
 	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
-	    if (attrib.getOpacity () < OPAQUE ||
-		attrib.getBrightness () != BRIGHT)
+	    if (attrib.opacity < OPAQUE ||
+		attrib.brightness != BRIGHT)
 	    {
 		GL::activeTexture (GL_TEXTURE3_ARB);
 
 		texture->enable (filter);
 
-		constant[3] = attrib.getOpacity () / 65535.0f;
+		constant[3] = attrib.opacity / 65535.0f;
 		constant[0] = constant[1] = constant[2] = constant[3] *
-		    attrib.getBrightness () / 65535.0f;
+		    attrib.brightness / 65535.0f;
 
 		glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
@@ -1028,7 +902,7 @@
 		glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
 		glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
-		w->glDrawGeometry ();
+		w->vertexBuffer ()->render (transform, attrib);
 
 		texture->disable ();
 
@@ -1038,7 +912,7 @@
 	    }
 	    else
 	    {
-		w->glDrawGeometry ();
+		w->vertexBuffer ()->render (transform, attrib);
 	    }
 
 	    texture->disable ();
@@ -1055,9 +929,9 @@
 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
 	    glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
-	    constant[3] = attrib.getOpacity () / 65535.0f;
+	    constant[3] = attrib.opacity / 65535.0f;
 	    constant[0] = constant[1] = constant[2] = constant[3] *
-			  attrib.getBrightness ()/ 65535.0f;
+			  attrib.brightness / 65535.0f;
 
 	    constant[0] = 0.5f + 0.5f * RED_SATURATION_WEIGHT   * constant[0];
 	    constant[1] = 0.5f + 0.5f * GREEN_SATURATION_WEIGHT * constant[1];
@@ -1065,7 +939,7 @@
 
 	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
-	    w->glDrawGeometry ();
+	    w->vertexBuffer ()->render (transform, attrib);
 	}
 
 	texture->disable ();
@@ -1078,9 +952,6 @@
 
 	glColor4usv (defaultColor);
 	gs->setTexEnvMode (GL_REPLACE);
-
-	if (mask & PAINT_WINDOW_BLEND_MASK)
-	    glDisable (GL_BLEND);
     }
     else
     {
@@ -1088,57 +959,57 @@
 
 	if (mask & PAINT_WINDOW_BLEND_MASK)
 	{
-	    glEnable (GL_BLEND);
-	    if (attrib.getOpacity ()!= OPAQUE ||
-		attrib.getBrightness () != BRIGHT)
+	    if (attrib.opacity != OPAQUE ||
+		attrib.brightness != BRIGHT)
 	    {
 		GLushort color;
 
-		color = (attrib.getOpacity () * attrib.getBrightness ()) >> 16;
+		color = (attrib.opacity * attrib.brightness) >> 16;
 
 		gs->setTexEnvMode (GL_MODULATE);
-		glColor4us (color, color, color, attrib.getOpacity ());
+		glColor4us (color, color, color, attrib.opacity);
 
-		w->glDrawGeometry ();
+		w->vertexBuffer ()->render (transform, attrib);
 
 		glColor4usv (defaultColor);
 		gs->setTexEnvMode (GL_REPLACE);
 	    }
 	    else
 	    {
-		w->glDrawGeometry ();
+		w->vertexBuffer ()->render (transform, attrib);
 	    }
-
-	    glDisable (GL_BLEND);
 	}
-	else if (attrib.getBrightness () != BRIGHT)
+	else if (attrib.brightness != BRIGHT)
 	{
 	    gs->setTexEnvMode (GL_MODULATE);
-	    glColor4us (attrib.getBrightness (), attrib.getBrightness (),
-			attrib.getBrightness (), BRIGHT);
+	    glColor4us (attrib.brightness, attrib.brightness,
+			attrib.brightness, BRIGHT);
 
-	    w->glDrawGeometry ();
+	    w->vertexBuffer ()->render (transform, attrib);
 
 	    glColor4usv (defaultColor);
 	    gs->setTexEnvMode (GL_REPLACE);
 	}
 	else
 	{
-	    w->glDrawGeometry ();
+	    w->vertexBuffer ()->render (transform, attrib);
 	}
 
 	texture->disable ();
     }
 }
+#endif
 
 void
-GLWindow::glDrawTexture (GLTexture          *texture,
-			 GLFragment::Attrib &attrib,
-			 unsigned int       mask)
+GLWindow::glDrawTexture (GLTexture                 *texture,
+                         const GLMatrix            &transform,
+			 const GLWindowPaintAttrib &attrib,
+			 unsigned int              mask)
 {
-    WRAPABLE_HND_FUNC (3, glDrawTexture, texture, attrib, mask)
+    WRAPABLE_HND_FUNC (3, glDrawTexture, texture, transform, attrib, mask)
 
     GLTexture::Filter filter;
+    GLProgram *program = NULL;
 
     if (mask & (PAINT_WINDOW_TRANSFORMED_MASK |
 		PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK))
@@ -1146,24 +1017,36 @@
     else
 	filter = priv->gScreen->filter (NOTHING_TRANS_FILTER);
 
-    if ((!attrib.hasFunctions () && (!priv->gScreen->lighting () ||
-	 attrib.getSaturation () == COLOR || attrib.getSaturation () == 0)) ||
-	!enableFragmentProgramAndDrawGeometry (priv->gScreen, this, texture,
-					       attrib, filter, mask))
-    {
-	enableFragmentOperationsAndDrawGeometry (priv->gScreen, this, texture,
-						 attrib, filter, mask);
-    }
+    // add the opengl functions (main) to the shader list, use it, then clear it
+    addShaders ("opengl", vertex_shader, fragment_shader);
+    program = priv->gScreen->getProgram (priv->shaders);
+    priv->vertexBuffer->setProgram (program);
+    priv->shaders.clear ();
+
+    texture->enable (filter);
+
+    #ifdef USE_GLES
+    priv->vertexBuffer->render (transform, attrib);
+    #else
+
+    if (!GL::vbo)
+	enableLegacyOBSAndRender (priv->gScreen, this, texture, transform,
+                                  attrib, filter, mask);
+    else
+	priv->vertexBuffer->render (transform, attrib);
+    #endif
+
+    texture->disable ();
 }
 
 bool
-GLWindow::glDraw (const GLMatrix     &transform,
-		  GLFragment::Attrib &fragment,
-		  const CompRegion   &region,
-		  unsigned int       mask)
+GLWindow::glDraw (const GLMatrix            &transform,
+		  const GLWindowPaintAttrib &attrib,
+		  const CompRegion          &region,
+		  unsigned int              mask)
 {
     WRAPABLE_HND_FUNC_RETURN (1, bool, glDraw, transform,
-			      fragment, region, mask)
+			      attrib, region, mask)
 
     const CompRegion reg = (mask & PAINT_WINDOW_TRANSFORMED_MASK) ?
 	                   infiniteRegion : region;
@@ -1185,10 +1068,11 @@
     if (priv->textures.size () == 1)
     {
 	ml[0] = priv->matrices[0];
-	priv->geometry.reset ();
+	priv->vertexBuffer->begin ();
 	glAddGeometry (ml, priv->window->region (), reg);
-	if (priv->geometry.vCount)
-	    glDrawTexture (priv->textures[0], fragment, mask);
+	priv->vertexBuffer->end ();
+
+	glDrawTexture (priv->textures[0], transform, attrib, mask);
     }
     else
     {
@@ -1197,10 +1081,11 @@
 	for (unsigned int i = 0; i < priv->textures.size (); i++)
 	{
 	    ml[0] = priv->matrices[i];
-	    priv->geometry.reset ();
+	    priv->vertexBuffer->begin ();
 	    glAddGeometry (ml, priv->regions[i], reg);
-	    if (priv->geometry.vCount)
-		glDrawTexture (priv->textures[i], fragment, mask);
+	    priv->vertexBuffer->end ();
+
+	    glDrawTexture (priv->textures[i], transform, attrib, mask);
 	}
     }
 
@@ -1215,7 +1100,6 @@
 {
     WRAPABLE_HND_FUNC_RETURN (0, bool, glPaint, attrib, transform, region, mask)
 
-    GLFragment::Attrib fragment (attrib);
     bool               status;
 
     priv->lastPaint = attrib;
@@ -1245,18 +1129,7 @@
     if (mask & PAINT_WINDOW_NO_CORE_INSTANCE_MASK)
 	return true;
 
-    if (mask & PAINT_WINDOW_TRANSFORMED_MASK ||
-        mask & PAINT_WINDOW_WITH_OFFSET_MASK)
-    {
-	glPushMatrix ();
-	glLoadMatrixf (transform.getMatrix ());
-    }
-
-    status = glDraw (transform, fragment, region, mask);
-
-    if (mask & PAINT_WINDOW_TRANSFORMED_MASK ||
-        mask & PAINT_WINDOW_WITH_OFFSET_MASK)
-	glPopMatrix ();
+    status = glDraw (transform, attrib, region, mask);
 
     return status;
 }

=== removed file 'plugins/opengl/src/privatefragment.h'
--- plugins/opengl/src/privatefragment.h	2009-03-15 05:09:18 +0000
+++ plugins/opengl/src/privatefragment.h	1970-01-01 00:00:00 +0000
@@ -1,54 +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 _PRIVATEFRAGMENT_H
-#define _PRIVATEFRAGMENT_H
-
-#include <vector>
-
-#include <opengl/fragment.h>
-
-namespace GLFragment {
-
-    class Function;
-    class Program;
-
-    class Storage {
-	public:
-	    Storage ();
-	    ~Storage ();
-
-	public:
-	    int lastFunctionId;
-	    std::vector<Function *> functions;
-	    std::vector<Program *> programs;
-
-	    FunctionId saturateFunction[2][64];
-    };
-};
-
-#endif

=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2009-03-16 09:18:16 +0000
+++ plugins/opengl/src/privates.h	2011-08-10 17:09:44 +0000
@@ -32,8 +32,8 @@
 #include <opengl/opengl.h>
 #include <core/atoms.h>
 
-#include "privatefragment.h"
 #include "privatetexture.h"
+#include "privatevertexbuffer.h"
 #include "opengl_options.h"
 
 extern CompOutput *targetOutput;
@@ -72,8 +72,9 @@
 
 	void waitForVideoSync ();
 
-	void paintBackground (const CompRegion &region,
-			      bool             transformed);
+	void paintBackground (const GLMatrix   &transform,
+	                      const CompRegion &region,
+                              bool             transformed);
 
 	void paintOutputRegion (const GLMatrix   &transform,
 			        const CompRegion &region,
@@ -91,7 +92,9 @@
 
 	GLenum textureFilter;
 
+	#ifndef USE_GLES
 	GLFBConfig      glxPixmapFBConfigs[MAX_DEPTH + 1];
+	#endif
 
 	GLTexture::List backgroundTextures;
 	bool            backgroundLoaded;
@@ -100,16 +103,19 @@
 
 	CompPoint rasterPos;
 
-	GLFragment::Storage fragmentStorage;
-
-	GLfloat projection[16];
+	GLMatrix *projection;
 
 	bool clearBuffers;
 	bool lighting;
 
+	#ifdef USE_GLES
+	EGLContext ctx;
+	EGLSurface surface;
+	#else
+	GLXContext ctx;
+
 	GL::GLXGetProcAddressProc getProcAddress;
-
-	GLXContext ctx;
+	#endif
 
 	CompRegion outputRegion;
 
@@ -121,6 +127,8 @@
 	bool hasCompositing;
 
 	GLIcon defaultIcon;
+
+	GLProgramCache *programCache;
 };
 
 class PrivateGLWindow :
@@ -163,10 +171,14 @@
 
 	unsigned int lastMask;
 
-	GLWindow::Geometry geometry;
+	GLVertexBuffer *vertexBuffer;
+
+	// map of shaders, plugin name is key, pair of vertex and fragment
+	// shader source code is value
+	std::list<GLShaderData*> shaders;
 
 	std::list<GLIcon> icons;
 };
 
-
 #endif
+

=== modified file 'plugins/opengl/src/privatetexture.h'
--- plugins/opengl/src/privatetexture.h	2009-08-27 20:04:20 +0000
+++ plugins/opengl/src/privatetexture.h	2011-08-10 17:09:44 +0000
@@ -1,6 +1,7 @@
 /*
  * Copyright © 2008 Dennis Kasprzyk
  * Copyright © 2007 Novell, Inc.
+ * Copyright © 2011 Linaro Ltd.
  *
  * Permission to use, copy, modify, distribute, and sell this software
  * and its documentation for any purpose is hereby granted without
@@ -23,6 +24,7 @@
  *
  * Authors: Dennis Kasprzyk <[e-mail]>
  *          David Reveman <[e-mail]>
+ *          Travis Watkins <[e-mail]>
  */
 
 #ifndef _PRIVATETEXTURE_H
@@ -30,8 +32,15 @@
 
 #include <map>
 
+#ifdef USE_GLES
+#define SUPPORT_X11
+#include <GLES2/gl2.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
 #include <GL/gl.h>
 #include <GL/glx.h>
+#endif
 #include <opengl/texture.h>
 
 class GLScreen;
@@ -61,6 +70,28 @@
 	int               refCount;
 };
 
+#ifdef USE_GLES
+class EglTexture : public GLTexture {
+    public:
+	EglTexture ();
+	~EglTexture ();
+
+	void enable (Filter filter);
+
+	static List bindPixmapToTexture (Pixmap pixmap,
+					 int width,
+					 int height,
+					 int depth);
+
+    public:
+	bool        damaged;
+	Damage      damage;
+	bool        updateMipMap;
+};
+
+extern std::map<Damage, EglTexture*> boundPixmapTex;
+#else
+
 class TfpTexture : public GLTexture {
     public:
 	TfpTexture ();
@@ -81,5 +112,6 @@
 };
 
 extern std::map<Damage, TfpTexture*> boundPixmapTex;
+#endif
 
 #endif

=== added file 'plugins/opengl/src/privatevertexbuffer.h'
--- plugins/opengl/src/privatevertexbuffer.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/privatevertexbuffer.h	2011-08-10 17:09:44 +0000
@@ -0,0 +1,71 @@
+/*
+ * 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 _VERTEXBUFFER_PRIVATE_H
+#define _VERTEXBUFFER_PRIVATE_H
+
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include <opengl/program.h>
+
+class GLVertexBuffer;
+
+class PrivateVertexBuffer
+{
+    public:
+	PrivateVertexBuffer ();
+	~PrivateVertexBuffer ();
+
+	int render (const GLMatrix            &projection,
+	            const GLMatrix            &modelview,
+	            const GLWindowPaintAttrib &attrib);
+	int legacyRender (const GLMatrix            &projection,
+	                  const GLMatrix            &modelview,
+	                  const GLWindowPaintAttrib &attrib);
+
+    public:
+	static GLVertexBuffer *streamingBuffer;
+
+	std::vector<GLfloat> vertexData;
+	std::vector<GLfloat> normalData;
+	std::vector<GLfloat> colorData;
+	std::vector<std::vector<GLfloat> > textureData;
+
+	GLProgram *program;
+	GLenum primitiveType;
+	GLenum usage;
+
+	GLuint vertexBuffer;
+	GLuint normalBuffer;
+	GLuint colorBuffer;
+	std::vector<GLuint> textureBuffers;
+};
+
+#endif //_VERTEXBUFFER_PRIVATE_H
+

=== added file 'plugins/opengl/src/program.cpp'
--- plugins/opengl/src/program.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/program.cpp	2011-08-10 17:09:44 +0000
@@ -0,0 +1,225 @@
+/*
+ * 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]>
+ */
+
+#define GL_GLEXT_PROTOTYPES
+
+#include <iostream>
+#include <fstream>
+#include <opengl/program.h>
+
+class PrivateProgram
+{
+    public:
+	GLuint program;
+	bool valid;
+};
+
+
+void printShaderInfoLog (GLuint shader)
+{
+    GLint   length = 0;
+    GLint   chars  = 0;
+    GLchar *infoLog;
+
+    glGetShaderiv (shader, GL_INFO_LOG_LENGTH, &length);
+
+    if (length > 0)
+    {
+	infoLog = new GLchar[length];
+	glGetShaderInfoLog (shader, length, &chars, infoLog);
+	std::cout << infoLog << std::endl;
+	delete[] infoLog;
+    }
+}
+
+void printProgramInfoLog(GLuint program)
+{
+    GLint   length = 0;
+    GLint   chars  = 0;
+    GLchar *infoLog;
+
+    glGetProgramiv (program, GL_INFO_LOG_LENGTH, &length);
+
+    if (length > 0)
+    {
+	infoLog = new GLchar[length];
+	glGetProgramInfoLog (program, length, &chars, infoLog);
+	std::cout << infoLog << std::endl;
+	delete[] infoLog;
+    }
+}
+
+static bool compileShader (GLuint *shader, GLenum type, CompString &source)
+{
+    const GLchar *data;
+    GLint         status;
+
+    data = (GLchar *)source.c_str ();
+
+    *shader = glCreateShader (type);
+    glShaderSource (*shader, 1, &data, NULL);
+    glCompileShader (*shader);
+
+    glGetShaderiv (*shader, GL_COMPILE_STATUS, &status);
+    return (status == GL_TRUE);
+}
+
+GLProgram::GLProgram (CompString &vertexShader, CompString &fragmentShader) :
+    priv (new PrivateProgram ())
+{
+    GLuint vertex, fragment;
+    GLint status;
+
+    priv->valid = false;
+    priv->program = glCreateProgram ();
+
+    if (!compileShader (&vertex, GL_VERTEX_SHADER, vertexShader))
+    {
+	printShaderInfoLog (vertex);
+	std::cout << vertexShader << std::endl << std::endl;
+	return;
+    }
+
+    if (!compileShader (&fragment, GL_FRAGMENT_SHADER, fragmentShader))
+    {
+	printShaderInfoLog (fragment);
+	std::cout << fragmentShader << std::endl << std::endl;
+	return;
+    }
+
+    glAttachShader (priv->program, vertex);
+    glAttachShader (priv->program, fragment);
+
+    glLinkProgram (priv->program);
+    glValidateProgram (priv->program);
+
+    glGetProgramiv (priv->program, GL_LINK_STATUS, &status);
+    if (status == GL_FALSE)
+    {
+	printProgramInfoLog (priv->program);
+	return;
+    }
+
+    glDeleteShader (vertex);
+    glDeleteShader (fragment);
+
+    priv->valid = true;
+}
+
+GLProgram::~GLProgram ()
+{
+    glDeleteProgram (priv->program);
+    delete priv;
+}
+
+bool GLProgram::valid ()
+{
+    return priv->valid;
+}
+
+void GLProgram::bind ()
+{
+    glUseProgram (priv->program);
+}
+
+void GLProgram::unbind ()
+{
+    glUseProgram (0);
+}
+
+bool GLProgram::setUniform (const char *name, GLfloat value)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniform1f (location, value);
+    return true;
+}
+
+bool GLProgram::setUniform (const char *name, GLint value)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniform1i (location, value);
+    return true;
+}
+
+bool GLProgram::setUniform (const char *name, const GLMatrix &value)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniformMatrix4fv (location, 1, GL_FALSE, value.getMatrix ());
+    return true;
+}
+
+bool GLProgram::setUniform2f (const char *name,
+                              GLfloat x,
+                              GLfloat y)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniform2f (location, x, y);
+    return true;
+}
+
+bool GLProgram::setUniform3f (const char *name,
+                              GLfloat x,
+                              GLfloat y,
+                              GLfloat z)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniform3f (location, x, y, z);
+    return true;
+}
+
+bool GLProgram::setUniform4f (const char *name,
+                              GLfloat x,
+                              GLfloat y,
+                              GLfloat z,
+                              GLfloat w)
+{
+    GLint location = glGetUniformLocation (priv->program, name);
+    if (location == -1)
+	return false;
+
+    glUniform4f (location, x, y, z, w);
+    return true;
+}
+
+GLuint GLProgram::attributeLocation (const char *name)
+{
+    return glGetAttribLocation (priv->program, name);
+}
+

=== added file 'plugins/opengl/src/programcache.cpp'
--- plugins/opengl/src/programcache.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/programcache.cpp	2011-08-10 17:09:44 +0000
@@ -0,0 +1,175 @@
+/*
+ * Copyright © 2011 Linaro Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Linaro Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Linaro Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Travis Watkins <[e-mail]>
+ */
+
+#include <opengl/programcache.h>
+#include "privates.h"
+
+typedef std::list<std::string> access_history_t;
+typedef std::pair<GLProgram*, access_history_t::iterator> value;
+
+static GLProgram *
+compileProgram (std::string name, std::list<GLShaderData*> shaders)
+{
+    std::list<GLShaderData*>::iterator it;
+    std::string vertex_shader;
+    std::string fragment_shader;
+    std::string vertex_functions = "";
+    std::string vertex_function_calls = "";
+    std::string fragment_functions = "";
+    std::string fragment_function_calls = "";
+    int vpos, vcallpos, fpos, fcallpos;
+
+    for (it = shaders.begin (); it != shaders.end (); it++)
+    {
+	//find the special shaders to put the rest in
+	if ((*it)->vertex_shader.find ("@VERTEX_FUNCTIONS@") != std::string::npos)
+	{
+	    vertex_shader = (*it)->vertex_shader;
+	}
+	else
+	{
+	    if ((*it)->vertex_shader.length ())
+	    {
+		vertex_functions += (*it)->vertex_shader;
+		vertex_function_calls += (*it)->name + "_vertex();\n";
+	    }
+	}
+
+	if ((*it)->fragment_shader.find ("@FRAGMENT_FUNCTIONS@") != std::string::npos)
+	{
+	    fragment_shader = (*it)->fragment_shader;
+	}
+	else
+	{
+	    if ((*it)->fragment_shader.length ())
+	    {
+		fragment_functions += (*it)->fragment_shader;
+		fragment_function_calls += (*it)->name + "_fragment();\n";
+	    }
+	}
+    }
+
+    // put shader functions and function calls into the main shader
+    vpos = vertex_shader.find ("@VERTEX_FUNCTIONS@");
+    vertex_shader.replace (vpos, 18, vertex_functions);
+
+    vcallpos = vertex_shader.find ("@VERTEX_FUNCTION_CALLS@");
+    vertex_shader.replace (vcallpos, 23, vertex_function_calls);
+
+    fpos = fragment_shader.find ("@FRAGMENT_FUNCTIONS@");
+    fragment_shader.replace (fpos, 20, fragment_functions);
+
+    fcallpos = fragment_shader.find ("@FRAGMENT_FUNCTION_CALLS@");
+    fragment_shader.replace (fcallpos, 25, fragment_function_calls);
+
+    return new GLProgram (vertex_shader, fragment_shader);
+}
+
+class PrivateProgramCache
+{
+    public:
+	PrivateProgramCache (size_t);
+
+	const size_t                 capacity;
+	access_history_t             access_history;
+	std::map<std::string, value> cache;
+
+	void insert (std::string, GLProgram *);
+	void evict ();
+};
+
+GLProgramCache::GLProgramCache (size_t capacity) :
+    priv (new PrivateProgramCache (capacity))
+{
+    assert (priv->capacity != 0);
+}
+
+GLProgramCache::~GLProgramCache ()
+{
+    delete priv;
+}
+ 
+GLProgram* GLProgramCache::operator () (std::list<GLShaderData*> shaders)
+{
+    std::list<GLShaderData*>::iterator name_it;
+    std::string name;
+
+    for (name_it = shaders.begin(); name_it != shaders.end(); name_it++)
+    {
+	if (name.length () == 0)
+	    name += (*name_it)->name;
+	else
+	    name += ":" + (*name_it)->name;
+    }
+
+    std::map<std::string, value>::iterator it = priv->cache.find (name);
+ 
+    if (it == priv->cache.end ())
+    {
+	GLProgram *program = compileProgram (name, shaders);
+	priv->insert (name, program);
+	return program;
+    }
+    else
+    {
+	priv->access_history.splice (priv->access_history.end (),
+	                             priv->access_history,
+	                             (*it).second.second);
+	(*it).second.second = priv->access_history.rbegin ().base ();
+
+	return (*it).second.first;
+    }
+}
+
+PrivateProgramCache::PrivateProgramCache (size_t c) :
+    capacity (c)
+{
+}
+
+void PrivateProgramCache::insert (std::string name, GLProgram *program)
+{
+    assert (cache.find (name) == cache.end ());
+
+    if (cache.size () == capacity)
+	evict ();
+
+    // update most recently used GLProgram
+    access_history_t::iterator it = access_history.insert (access_history.end (), name);
+
+    cache.insert (std::make_pair (name, std::make_pair (program, it)));
+}
+
+void PrivateProgramCache::evict ()
+{
+    assert (!access_history.empty ());
+
+    // find least recently used GLProgram
+    std::map<std::string, value>::iterator it = cache.find (access_history.front ());
+    assert (it != cache.end ());
+ 
+    cache.erase (it);
+    access_history.pop_front ();
+}
+

=== modified file 'plugins/opengl/src/screen.cpp'
--- plugins/opengl/src/screen.cpp	2011-02-24 07:52:09 +0000
+++ plugins/opengl/src/screen.cpp	2011-08-10 17:09:44 +0000
@@ -1,4 +1,5 @@
 /*
+ * Copyright © 2011 Linaro Ltd.
  * Copyright © 2008 Dennis Kasprzyk
  * Copyright © 2007 Novell, Inc.
  *
@@ -23,6 +24,7 @@
  *
  * Authors: Dennis Kasprzyk <[e-mail]>
  *          David Reveman <[e-mail]>
+ *          Travis Watkins <[e-mail]>
  */
 
 #include "privates.h"
@@ -31,6 +33,13 @@
 #include <math.h>
 
 namespace GL {
+    #ifdef USE_GLES
+    EGLCreateImageKHRProc  createImage;
+    EGLDestroyImageKHRProc destroyImage;
+
+    GLEGLImageTargetTexture2DOESProc eglImageTargetTexture;
+    #else
+
     GLXBindTexImageProc      bindTexImage = NULL;
     GLXReleaseTexImageProc   releaseTexImage = NULL;
     GLXQueryDrawableProc     queryDrawable = NULL;
@@ -42,10 +51,6 @@
     GLXCreatePixmapProc      createPixmap = NULL;
     GLXDestroyPixmapProc     destroyPixmap = NULL;
 
-    GLActiveTextureProc       activeTexture = NULL;
-    GLClientActiveTextureProc clientActiveTexture = NULL;
-    GLMultiTexCoord2fProc     multiTexCoord2f = NULL;
-
     GLGenProgramsProc	     genPrograms = NULL;
     GLDeleteProgramsProc     deletePrograms = NULL;
     GLBindProgramProc	     bindProgram = NULL;
@@ -53,6 +58,11 @@
     GLProgramParameter4fProc programEnvParameter4f = NULL;
     GLProgramParameter4fProc programLocalParameter4f = NULL;
     GLGetProgramivProc       getProgramiv = NULL;
+    #endif
+
+    GLActiveTextureProc       activeTexture = NULL;
+    GLClientActiveTextureProc clientActiveTexture = NULL;
+    GLMultiTexCoord2fProc     multiTexCoord2f = NULL;
 
     GLGenFramebuffersProc        genFramebuffers = NULL;
     GLDeleteFramebuffersProc     deleteFramebuffers = NULL;
@@ -61,6 +71,12 @@
     GLFramebufferTexture2DProc   framebufferTexture2D = NULL;
     GLGenerateMipmapProc         generateMipmap = NULL;
 
+    GLBindBufferProc    bindBuffer = NULL;
+    GLDeleteBuffersProc deleteBuffers = NULL;
+    GLGenBuffersProc    genBuffers = NULL;
+    GLBufferDataProc    bufferData = NULL;
+    GLBufferSubDataProc bufferSubData = NULL;
+
     bool  textureFromPixmap = true;
     bool  textureRectangle = false;
     bool  textureNonPowerOfTwo = false;
@@ -70,6 +86,7 @@
     bool  textureCompression = false;
     GLint maxTextureSize = 0;
     bool  fbo = false;
+    bool  vbo = false;
     bool  fragmentProgram = false;
     GLint maxTextureUnits = 1;
 
@@ -83,6 +100,179 @@
     PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI> (s),
     priv (new PrivateGLScreen (this))
 {
+    #ifdef USE_GLES
+    Display             *xdpy;
+    Window               overlay;
+    EGLDisplay           dpy;
+    EGLConfig            config;
+    EGLint               major, minor;
+    const char		*eglExtensions, *glExtensions;
+    XWindowAttributes    attr;
+    EGLint               count, visualid;
+    EGLConfig            configs[1024];
+    CompOption::Vector   o (0);
+
+    const EGLint config_attribs[] = {
+	EGL_SURFACE_TYPE,         EGL_WINDOW_BIT,
+	EGL_RED_SIZE,             1,
+	EGL_GREEN_SIZE,           1,
+	EGL_BLUE_SIZE,            1,
+	EGL_ALPHA_SIZE,           0,
+	EGL_RENDERABLE_TYPE,      EGL_OPENGL_ES2_BIT,
+	EGL_CONFIG_CAVEAT,        EGL_NONE,
+	EGL_NONE,
+    };
+
+    const EGLint context_attribs[] = {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+
+    xdpy = s->dpy ();
+    dpy = eglGetDisplay ((EGLNativeDisplayType)xdpy);
+    if (!eglInitialize (dpy, &major, &minor))
+    {
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    eglBindAPI (EGL_OPENGL_ES_API);
+
+    if (!eglChooseConfig (dpy, config_attribs, configs, 1024, &count))
+    {
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    if (!XGetWindowAttributes (xdpy, s->root (), &attr))
+    {
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    visualid = XVisualIDFromVisual (attr.visual);
+    config = configs[0];
+    for (int i = 0; i < count; i++) {
+        EGLint val;
+        eglGetConfigAttrib (dpy, configs[i], EGL_NATIVE_VISUAL_ID, &val);
+        if (visualid == val) {
+            config = configs[i];
+            break;
+        }
+    }
+
+    overlay = CompositeScreen::get (s)->overlay ();
+    priv->surface = eglCreateWindowSurface (dpy, config, overlay, 0);
+    if (priv->surface == EGL_NO_SURFACE)
+    {
+	compLogMessage ("opengl", CompLogLevelFatal,
+	                "eglCreateWindowSurface failed");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    priv->ctx = eglCreateContext (dpy, config, EGL_NO_CONTEXT, context_attribs);
+    if (priv->ctx == EGL_NO_CONTEXT)
+    {
+	compLogMessage ("opengl", CompLogLevelFatal, "eglCreateContext failed");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    if (!eglMakeCurrent (dpy, priv->surface, priv->surface, priv->ctx))
+    {
+	compLogMessage ("opengl", CompLogLevelFatal,
+	                "eglMakeCurrent failed");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    eglExtensions = (const char *) eglQueryString (dpy, EGL_EXTENSIONS);
+    glExtensions = (const char *) glGetString (GL_EXTENSIONS);
+
+    if (!glExtensions || !eglExtensions)
+    {
+	compLogMessage ("opengl", CompLogLevelFatal,
+			"No valid GL extensions string found.");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+    GL::textureFromPixmap = true;
+    GL::textureNonPowerOfTwo = true;
+    GL::fbo = true;
+    GL::vbo = true;
+    GL::maxTextureUnits = 4;
+    glGetIntegerv (GL_MAX_TEXTURE_SIZE, &GL::maxTextureSize);
+
+    GL::createImage = (GL::EGLCreateImageKHRProc)
+	eglGetProcAddress ("eglCreateImageKHR");
+    GL::destroyImage = (GL::EGLDestroyImageKHRProc)
+	eglGetProcAddress ("eglDestroyImageKHR");
+    GL::eglImageTargetTexture = (GL::GLEGLImageTargetTexture2DOESProc)
+	eglGetProcAddress ("glEGLImageTargetTexture2DOES");
+
+    if (!strstr (eglExtensions, "EGL_KHR_image_pixmap") ||
+        !strstr (glExtensions, "GL_OES_EGL_image") ||
+	!GL::createImage || !GL::destroyImage || !GL::eglImageTargetTexture)
+    {
+	compLogMessage ("opengl", CompLogLevelFatal,
+			"GL_OES_EGL_image is missing");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+
+// work around efika supporting GL_BGRA directly instead of via this extension
+#ifndef GL_BGRA
+    if (!strstr (glExtensions, "GL_EXT_texture_format_BGRA8888"))
+    {
+	compLogMessage ("opengl", CompLogLevelFatal,
+			"GL_EXT_texture_format_BGRA8888 is missing");
+	screen->handleCompizEvent ("opengl", "fatal_fallback", o);
+	setFailed ();
+	return;
+    }
+#endif
+
+    GL::activeTexture = glActiveTexture;
+    GL::genFramebuffers = glGenFramebuffers;
+    GL::deleteFramebuffers = glDeleteFramebuffers;
+    GL::bindFramebuffer = glBindFramebuffer;
+    GL::checkFramebufferStatus = glCheckFramebufferStatus;
+    GL::framebufferTexture2D = glFramebufferTexture2D;
+    GL::generateMipmap = glGenerateMipmap;
+
+    GL::bindBuffer = glBindBuffer;
+    GL::deleteBuffers = glDeleteBuffers;
+    GL::genBuffers = glGenBuffers;
+    GL::bufferData = glBufferData;
+    GL::bufferSubData = glBufferSubData;
+
+    glClearColor (0.0, 0.0, 0.0, 1.0);
+    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable (GL_CULL_FACE);
+
+    priv->updateView ();
+
+    priv->lighting = false;
+
+    priv->filter[NOTHING_TRANS_FILTER] = GLTexture::Fast;
+    priv->filter[SCREEN_TRANS_FILTER]  = GLTexture::Good;
+    priv->filter[WINDOW_TRANS_FILTER]  = GLTexture::Good;
+
+    if (GL::textureFromPixmap)
+	registerBindPixmap (EglTexture::bindPixmapToTexture);
+
+    #else
+
     Display		 *dpy = s->dpy ();
     XVisualInfo		 templ;
     XVisualInfo		 *visinfo;
@@ -359,6 +549,27 @@
 	    GL::fbo = true;
     }
 
+    if (strstr (glExtensions, "GL_ARB_vertex_buffer_object"))
+    {
+	GL::bindBuffer = (GL::GLBindBufferProc)
+	    getProcAddress ("glBindBufferARB");
+	GL::deleteBuffers = (GL::GLDeleteBuffersProc)
+	    getProcAddress ("glDeleteBuffersARB");
+	GL::genBuffers = (GL::GLGenBuffersProc)
+	    getProcAddress ("glGenBuffersARB");
+	GL::bufferData = (GL::GLBufferDataProc)
+	    getProcAddress ("glBufferDataARB");
+	GL::bufferSubData = (GL::GLBufferSubDataProc)
+	    getProcAddress ("glBufferSubDataARB");
+
+	if (GL::bindBuffer    &&
+	    GL::deleteBuffers &&
+	    GL::genBuffers    &&
+	    GL::bufferData    &&
+	    GL::bufferSubData)
+	    GL::vbo = true;
+    }
+
     if (strstr (glExtensions, "GL_ARB_texture_compression"))
 	GL::textureCompression = true;
 
@@ -495,7 +706,6 @@
     glClearColor (0.0, 0.0, 0.0, 1.0);
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glEnable (GL_CULL_FACE);
-    glDisable (GL_BLEND);
     glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
     glColor4usv (defaultColor);
     glEnableClientState (GL_VERTEX_ARRAY);
@@ -530,14 +740,27 @@