Merge lp:~compiz-linaro-team/compiz/gles2 into lp:compiz/0.9.8

[Daniel van Vugt]

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
* GLShaderCache class added for managing dynamically created shader source
  code.
* GLFragment class removed as fragment programs are no longer used (replaced
  with GLSL programs)
* EGL context setup added
* EglTexture class added to use EGL_image extension instead of
  GLX_EXT_texture_from_pixmap for GLES

WARNING: The Preview diff is incomplete due to Launchpad limitations. Please click Download diff to get the whole thing.

BUGS: Yes, there a quite a few still but I think they're acceptable now. The full list of known bugs in this branch is: https://bugs.launchpad.net/compiz/+bugs?field.tag=gles
and the bugs it causes in Unity:
https://bugs.launchpad.net/unity/+bugs?field.tag=gles

[Sam Spilsbury (smspillaz)]

The diff is quite large, however it should be possible still to do a code review:

+static bool
+unproject (float winx, float winy, float winz,
+ const GLMatrix &modelview,
+ const GLMatrix &projection,
+ const GLint viewport[4],
+ float *objx, float *objy, float *objz)
+{
+ GLMatrix finalMatrix = projection * modelview;
+ float in[4], out[4];
+
+ if (!finalMatrix.invert ())
+ return false;
+
+ in[0] = winx;
+ in[1] = winy;
+ in[2] = winz;
+ in[3] = 1.0;
+
+ /* Map x and y from window coordinates */
+ in[0] = (in[0] - viewport[0]) / viewport[2];
+ in[1] = (in[1] - viewport[1]) / viewport[3];
+
+ /* Map to range -1 to 1 */
+ in[0] = in[0] * 2 - 1;
+ in[1] = in[1] * 2 - 1;
+ in[2] = in[2] * 2 - 1;
+
+ for (int i = 0; i < 4; i++)
+ {
+ out[i] = in[0] * finalMatrix[i] +
+ in[1] * finalMatrix[4 + i] +
+ in[2] * finalMatrix[8 + i] +
+ in[3] * finalMatrix[12 + i];
+ }
+
+ if (out[3] == 0.0)
+ return false;
+
+ out[0] /= out[3];
+ out[1] /= out[3];
+ out[2] /= out[3];
+
+ *objx = out[0];
+ *objy = out[1];
+ *objz = out[2];
+
+ return true;
+}
+

+static bool
+project (float objx, float objy, float objz,
+ const float modelview[16], const float projection[16],
+ const GLint viewport[4],
+ float *winx, float *winy, float *winz)
+{
+ unsigned int i;
+ float in[4];
+ float out[4];
+
+ in[0] = objx;
+ in[1] = objy;
+ in[2] = objz;
+ in[3] = 1.0;
+
+ for (i = 0; i < 4; i++) {
+ out[i] =
+ in[0] * modelview[i] +
+ in[1] * modelview[4 + i] +
+ in[2] * modelview[8 + i] +
+ in[3] * modelview[12 + i];
+ }
+
+ for (i = 0; i < 4; i++) {
+ in[i] =
+ out[0] * projection[i] +
+ out[1] * projection[4 + i] +
+ out[2] * projection[8 + i] +
+ out[3] * projection[12 + i];
+ }
+
+ if (in[3] == 0.0)
+ return false;
+
+ in[0] /= in[3];
+ in[1] /= in[3];
+ in[2] /= in[3];
+ /* Map x, y and z to range 0-1 */
+ in[0] = in[0] * 0.5 + 0.5;
+ in[1] = in[1] * 0.5 + 0.5;
+ in[2] = in[2] * 0.5 + 0.5;
+
+ /* Map x,y to viewport */
+ in[0] = in[0] * viewport[2] + viewport[0];
+ in[1] = in[1] * viewport[3] + viewport[1];
+
+ *winx = in[0];
+ *winy = in[1];
+ *winz = in[2];
+ return true;
+}

This is re-usable in cube and should be put somewhere. GLMatrix?

=== added file 'cmake/FindOpenGLES2.cmake'
--- cmake/FindOpenGLES2.cmake 1970-01-01 00:00:00 +0000
+++ cmake/FindOpenGLES2.cmake 2012-08-10 08:27:48 +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_L...

[Daniel van Vugt (vanvugt)]

Thanks Sam. Please try to keep your comments a manageable size. Or make each point in a new comment.

[Daniel van Vugt (vanvugt)]

Initially I thought *project should go in GLMatrix too. However then I cleaned up project() and realized it should not be using GLMatrix. It looks like unproject similarly should not be using GLMatrix. Though *project() should probably live somewhere in the opengl plugin, I agree.

[Daniel van Vugt (vanvugt)]

Set to work in progress again.

We cannot realistically consider merging this until the incompatibilities with Unity are also fixed:
https://bugs.launchpad.net/unity/+bugs?field.tag=gles

[Sam Spilsbury (smspillaz)]

> 2. It's ugly, bad design. Member data should not be repeatedly passed as
     a parameter. I know there is a limitation in the current wrapping/
     interface design that makes it impossible to access vertexBuffer as a
     member, but that's no excuse for making the code worse than it already
     was.

Can you clarify this please? It didn't come up in the original review and I'm suprised you've put it as a reason for reverting it now.

While passing member data through function arguments is not great, it at least restricts the scope in which that data can be accessed, which is the correct thing to do.

I can understand reverting it in the meantime because unity is difficult to port with ifdefs, but if you're going to do so please consult with the person who wrote it (who happens to live in the same timezone as you, so its really not an issue to do so) for advice on how to handle it rather than taking the unilateral approach of just reverting code.

[Daniel van Vugt (vanvugt)]

I was extremely frustrated yesterday and just wanted the code to build. I wasn't feeling like consulting.

Sorry, I thought it did come up in the original review. I was thinking it all along but (as usual) failed to articulate all of my thoughts into words.

It's foreseeable that I will approve the changes again. But not until Unity has been updated to support them first. That would be enclosed in "#if COMPIZ_OPENGL_ABI >= 6", I imagine.

[Sam Spilsbury (smspillaz)]

> I was extremely frustrated yesterday and just wanted the code to build. I
> wasn't feeling like consulting.
>
> Sorry, I thought it did come up in the original review. I was thinking it all
> along but (as usual) failed to articulate all of my thoughts into words.
>
> It's foreseeable that I will approve the changes again. But not until Unity
> has been updated to support them first. That would be enclosed in "#if
> COMPIZ_OPENGL_ABI >= 6", I imagine.

Okay, thanks. Noted, will re-propose the unrevert of those changes at an appropriate time.

Cheers,

Sam

[Daniel van Vugt (vanvugt)]

OK, I /think/ the worst of the Unity regressions are now fixed, or at least with fixes proposed:
https://bugs.launchpad.net/unity/+bugs?field.tag=gles

Let's open this for review again. But be aware I may not action some of the optional cleanups (already mentioned) before this branch lands.

[Omer Akram (om26er)]

Nice work btw, working through all those regression along the way :-)

[Sam Spilsbury (smspillaz)]

Tested on nouveau, intel and ongoing testing was done on ARM/PowerVR too.

I'm happy enough for this to go in as-is, obviously it isn't yet release quality, however we need to put it in before feature freeze.

Things I would like to see actioned during the rest of the release period.

1. Tests. Tests. Tests
 a. Specifically on the behaviour of GLVertexBuffer, GLFramebufferObject and GLShaderCache
 b. No need for test coverage on areas where the API changed
2. GLVertexBuffer begin/end - that's bad design we need to fix it
3. Need to remove direct access to GLVertexBuffer in GLWindow
4. Sort out the mipmapping story on mesa drivers (add a driver workaround?)
5. project/unproject need to go somewhere common
6. Port/Drop blur
7. Port the rest of mag.
8. compiz-opengl-impl.h
9. Remove spurious ifdefs
10. Remove the options to control rendering features.

review: Approve

[Daniel van Vugt (vanvugt)]

A couple of new blockers were found/introduced today :(

review: Needs Fixing

[Daniel van Vugt (vanvugt)]

https://bugs.launchpad.net/compiz/+bugs?field.tag=gles

[Daniel van Vugt (vanvugt)]

review: Approve

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-compiz-core/66/console reported an error when processing this lp:~compiz-linaro-team/compiz/gles2 branch.
Not merging it.

=== modified file 'cmake/CMakeLists.txt'
--- cmake/CMakeLists.txt	2012-07-29 03:23:28 +0000
+++ cmake/CMakeLists.txt	2012-08-22 06:16:22 +0000
@@ -17,6 +17,8 @@
       plugin_extensions/CompizGenInstallData.cmake)
 list (APPEND _PluginExtensionFiles
       plugin_extensions/CompizGenInstallImages.cmake)
+list (APPEND _PluginExtensionFiles
+      plugin_extensions/CompizOpenGLFixups.cmake)
 
 if (USE_GCONF)
     list (APPEND _files CompizGconf.cmake)

=== modified file 'cmake/CompizCommon.cmake'
--- cmake/CompizCommon.cmake	2012-08-16 03:24:02 +0000
+++ cmake/CompizCommon.cmake	2012-08-22 06:16:22 +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)
+
 # Parse arguments passed to a function into several lists separated by
 # upper-case identifiers and options that do not have an associated list e.g.:
 #

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

=== modified file 'cmake/FindCompiz.cmake'
--- cmake/FindCompiz.cmake	2012-07-29 03:23:28 +0000
+++ cmake/FindCompiz.cmake	2012-08-22 06:16:22 +0000
@@ -89,7 +89,7 @@
 	if (COMPIZ_FOUND AND _compiz_def_macro)
             # everything found. Set module path and include defaults module
 	    set (COMPIZ_CMAKE_MODULE_PATH ${COMPIZ_PREFIX}/share/compiz/cmake)
-	    set (CMAKE_MODULE_PATH  ${COMPIZ_CMAKE_MODULE_PATH})
+	    set (CMAKE_MODULE_PATH ${COMPIZ_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH})
 	    include (CompizDefaults)
 	else ()
 	    set (COMPIZ_FOUND 0)

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

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

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

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

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2012-06-24 09:00:27 +0000
+++ plugins/CMakeLists.txt	2012-08-22 06:16:22 +0000
@@ -25,4 +25,34 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/../logmessage/include
 )
 
+# temporarily disable plugins that aren't ported yed
+set (COMPIZ_DISABLE_PLUGIN_ANIMATIONADDON ON)
+set (COMPIZ_DISABLE_PLUGIN_BICUBIC ON)
+set (COMPIZ_DISABLE_PLUGIN_BLUR ON)
+set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)
+set (COMPIZ_DISABLE_PLUGIN_CUBEADDON ON)
+set (COMPIZ_DISABLE_PLUGIN_GEARS ON)
+set (COMPIZ_DISABLE_PLUGIN_GROUP ON)
+set (COMPIZ_DISABLE_PLUGIN_LOGINOUT ON)
+set (COMPIZ_DISABLE_PLUGIN_REFLEX ON)
+set (COMPIZ_DISABLE_PLUGIN_THUMBNAIL ON)
+set (COMPIZ_DISABLE_PLUGIN_STACKSWITCH ON)
+set (COMPIZ_DISABLE_PLUGIN_WALLPAPER ON)
+set (COMPIZ_DISABLE_PLUGIN_TRIP ON)
+
+# disable plugins which won't work on ES2 builds
+if (BUILD_GLES)
+
+    set (COMPIZ_DISABLE_PLUGIN_TD ON)
+    set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)
+    set (COMPIZ_DISABLE_PLUGIN_MBLUR ON)
+    set (COMPIZ_DISABLE_PLUGIN_BENCH ON)
+    set (COMPIZ_DISABLE_PLUGIN_FIREPAINT ON)
+    set (COMPIZ_DISABLE_PLUGIN_SHOWREPAINT ON)
+    set (COMPIZ_DISABLE_PLUGIN_WIDGET ON)
+    set (COMPIZ_DISABLE_PLUGIN_SHOWMOUSE ON)
+    set (COMPIZ_DISABLE_PLUGIN_SPLASH ON)
+
+endif (BUILD_GLES)
+
 compiz_add_plugins_in_folder (${CMAKE_CURRENT_SOURCE_DIR})

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

=== modified file 'plugins/animation/include/animation/animation.h'
--- plugins/animation/include/animation/animation.h	2012-08-16 09:47:15 +0000
+++ plugins/animation/include/animation/animation.h	2012-08-22 06:16:22 +0000
@@ -3,8 +3,8 @@
 
 #define ANIMATION_ABI 20091205
 
+#include <core/core.h>
 #include <core/pluginclasshandler.h>
-#include <opengl/fragment.h>
 
 typedef enum
 {

=== modified file 'plugins/animation/include/animation/animeffect.h'
--- plugins/animation/include/animation/animeffect.h	2012-08-20 14:24:34 +0000
+++ plugins/animation/include/animation/animeffect.h	2012-08-22 06:16:22 +0000
@@ -88,7 +88,7 @@
     
     int mOverrideProgressDir;	///< 0: default dir, 1: forward, 2: backward
     
-    GLFragment::Attrib mCurPaintAttrib;
+    GLWindowPaintAttrib mCurPaintAttrib;
     GLushort mStoredOpacity;
     WindowEvent mCurWindowEvent;
     bool mInitialized; ///< whether the animation is initialized (in preparePaint)
@@ -195,7 +195,7 @@
     virtual ExtensionPluginInfo *getExtensionPluginInfo ();
 
     void drawTexture (GLTexture          *texture,
-		      GLFragment::Attrib &attrib,
+                      const GLWindowPaintAttrib &attrib,
 		      unsigned int       mask);
 
     // Utility methods
@@ -221,7 +221,7 @@
 				  GLMatrix &transform);
     void setInitialized () { mInitialized = true; }
     inline bool initialized () { return mInitialized; }
-    inline void setCurPaintAttrib (GLFragment::Attrib &newAttrib)
+    inline void setCurPaintAttrib (const GLWindowPaintAttrib &newAttrib)
     { mCurPaintAttrib = newAttrib; }
 };
 #endif

=== modified file 'plugins/animation/include/animation/grid.h'
--- plugins/animation/include/animation/grid.h	2012-04-10 06:13:37 +0000
+++ plugins/animation/include/animation/grid.h	2012-08-22 06:16:22 +0000
@@ -78,8 +78,6 @@
     /// ( http://www.r3.nu/~cass/qcoord/ )
     bool mUseQTexCoord;
 
-    GLWindow::Geometry mGeometry; ///< geometry for grid mesh
-
     virtual bool using3D () { return false; }
 
     virtual bool requiresTransformedWindow () const { return true; }

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2012-08-20 14:24:34 +0000
+++ plugins/animation/src/animation.cpp	2012-08-22 06:16:22 +0000
@@ -26,6 +26,10 @@
  * Particle system added by : (C) 2006 Dennis Kasprzyk
  * E-mail                   : [e-mail]
  *
+ * Ported to GLES by : Travis Watkins
+ *                     (C) 2011 Linaro Limited
+ * E-mail            : [e-mail]
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -80,8 +84,9 @@
  *
  */
 
-#include <GL/glu.h>
 #include <core/atoms.h>
+#include <core/core.h>
+#include <opengl/opengl.h>
 #include <sys/time.h>
 #include <assert.h>
 #include "private.h"
@@ -807,6 +812,58 @@
 		       coordsTransformed[GLVector::y]);
 }
 
+static bool
+project (float objx, float objy, float objz, 
+         const float modelview[16], const float projection[16],
+         const GLint viewport[4],
+         float *winx, float *winy, float *winz)
+{
+    unsigned int i;
+    float in[4];
+    float out[4];
+
+    in[0] = objx;
+    in[1] = objy;
+    in[2] = objz;
+    in[3] = 1.0;
+
+    for (i = 0; i < 4; i++) {
+	out[i] = 
+	    in[0] * modelview[i] +
+	    in[1] * modelview[4  + i] +
+	    in[2] * modelview[8  + i] +
+	    in[3] * modelview[12 + i];
+    }
+
+    for (i = 0; i < 4; i++) {
+	in[i] = 
+	    out[0] * projection[i] +
+	    out[1] * projection[4  + i] +
+	    out[2] * projection[8  + i] +
+	    out[3] * projection[12 + i];
+    }
+
+    if (in[3] == 0.0)
+	return false;
+
+    in[0] /= in[3];
+    in[1] /= in[3];
+    in[2] /= in[3];
+    /* Map x, y and z to range 0-1 */
+    in[0] = in[0] * 0.5 + 0.5;
+    in[1] = in[1] * 0.5 + 0.5;
+    in[2] = in[2] * 0.5 + 0.5;
+
+    /* Map x,y to viewport */
+    in[0] = in[0] * viewport[2] + viewport[0];
+    in[1] = in[1] * viewport[3] + viewport[1];
+
+    *winx = in[0];
+    *winy = in[1];
+    *winz = in[2];
+    return true;
+}
+
 /// Either points or objects should be non-0.
 bool
 AnimWindow::expandBBWithPoints3DTransform (CompOutput     &output,
@@ -815,27 +872,24 @@
 					   GridAnim::GridModel::GridObject *objects,
 					   unsigned int   nPoints)
 {
-    GLdouble dModel[16];
-    GLdouble dProjection[16];
-    GLdouble x, y, z;
-    for (unsigned int i = 0; i < 16; i++)
-    {
-	dModel[i] = transform[i];
-	dProjection[i] = GLScreen::get (::screen)->projectionMatrix ()[i];
-    }
+    GLfloat x, y, z;
     GLint viewport[4] =
 	{output.region ()->extents.x1,
 	 output.region ()->extents.y1,
 	 output.width (),
 	 output.height ()};
 
+    const float *projection =
+        GLScreen::get (::screen)->projectionMatrix ()->getMatrix ();
+
     if (points) // use points
     {
 	for (; nPoints; nPoints--, points += 3)
 	{
-	    if (!gluProject (points[0], points[1], points[2],
-			     dModel, dProjection, viewport,
-			     &x, &y, &z))
+	    if (!project (points[0], points[1], points[2],
+	                  transform.getMatrix (), projection,
+	                  viewport,
+	                  &x, &y, &z))
 		return false;
 
 	    expandBBWithPoint (x + 0.5, (::screen->height () - y) + 0.5);
@@ -846,11 +900,12 @@
 	GridAnim::GridModel::GridObject *object = objects;
 	for (; nPoints; nPoints--, object++)
 	{
-	    if (!gluProject (object->position ().x (),
-			     object->position ().y (),
-			     object->position ().z (),
-			     dModel, dProjection, viewport,
-			     &x, &y, &z))
+	    if (!project (object->position ().x (),
+	                  object->position ().y (),
+	                  object->position ().z (),
+	                  transform.getMatrix (), projection,
+	                  viewport,
+	                  &x, &y, &z))
 		return false;
 
 	    expandBBWithPoint (x + 0.5, (::screen->height () - y) + 0.5);
@@ -906,15 +961,10 @@
 void
 PrivateAnimWindow::damageThisAndLastStepRegion ()
 {
-#ifdef COMPIZ_OPENGL_SWAPBUFFERS_ALWAYS   // when LP: #901097 is fixed
     // Find union of the regions for this step and last step
     CompRegion totalRegionToDamage (mStepRegion + mLastStepRegion);
 
     mPAScreen->cScreen->damageRegion (totalRegionToDamage);
-#else
-    // Ugly fix for LP: #930192 while LP: #901097 is not resolved
-    mPAScreen->cScreen->damageScreen ();
-#endif
 }
 
 CompOutput &
@@ -1435,7 +1485,7 @@
 {
     gWindow->glPaintSetEnabled (this, enabling);
     gWindow->glAddGeometrySetEnabled (this, enabling);
-    gWindow->glDrawGeometrySetEnabled (this, enabling);
+    //gWindow->glDrawGeometrySetEnabled (this, enabling);
     gWindow->glDrawTextureSetEnabled (this, enabling);
 }
 
@@ -1509,7 +1559,8 @@
 
 void
 PrivateAnimWindow::glDrawTexture (GLTexture          *texture,
-				  GLFragment::Attrib &attrib,
+                                  const GLMatrix     &transform,
+                                  const GLWindowPaintAttrib &attrib,
 				  unsigned int       mask)
 {
     if (mCurAnimation)
@@ -1517,9 +1568,10 @@
 	mCurAnimation->setCurPaintAttrib (attrib);
     }
 
-    gWindow->glDrawTexture (texture, attrib, mask);
+    gWindow->glDrawTexture (texture, transform, attrib, mask);
 }
 
+#if 0 // Not ported yet
 void
 PrivateAnimWindow::glDrawGeometry ()
 {
@@ -1533,10 +1585,11 @@
 	gWindow->glDrawGeometry ();
     }
 }
+#endif
 
 void
 Animation::drawTexture (GLTexture          *texture,
-			GLFragment::Attrib &attrib,
+                        const GLWindowPaintAttrib &attrib,
 			unsigned int       mask)
 {
     mCurPaintAttrib = attrib;
@@ -1545,7 +1598,9 @@
 void
 Animation::drawGeometry ()
 {
+#if 0 // Not ported yet
     mAWindow->priv->gWindow->glDrawGeometry ();
+#endif
 }
 
 bool
@@ -1614,13 +1669,16 @@
 
     if (mCurAnimation->postPaintWindowUsed ())
     {
+#if 0 // Not ported yet
 	// Transform to make post-paint coincide with the window
 	glPushMatrix ();
 	glLoadMatrixf (wTransform.getMatrix ());
-
+#endif
 	mCurAnimation->postPaintWindow ();
 
+#if 0 // Not ported yet
 	glPopMatrix ();
+#endif
     }
 
     return status;

=== modified file 'plugins/animation/src/grid.cpp'
--- plugins/animation/src/grid.cpp	2010-10-23 15:41:33 +0000
+++ plugins/animation/src/grid.cpp	2012-08-22 06:16:22 +0000
@@ -19,6 +19,8 @@
  * Hexagon tessellator added by : Mike Slegeir
  * E-mail                       : [e-mail]>
  *
+ * Ported to GLVertexBuffer by: Daniel van Vugt <[e-mail]>
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -217,34 +219,19 @@
 		       unsigned int                maxGridWidth,
 		       unsigned int                maxGridHeight)
 {
-    unsigned int nMatrix = matrix.size ();
-    int nVertices, nIndices;
-    GLushort *i;
-    GLfloat *v;
-    int x1, y1, x2, y2;
+   
+    GLfloat *v, *vMax;
+    int y1, x2, y2;
     float winContentsY, winContentsHeight;
     float deformedX, deformedY;
     float deformedZ = 0;
-    int nVertX, nVertY;
     int vSize;
     float gridW, gridH;
-    bool rect = true;
     bool notUsing3dCoords = !using3D ();
 
     if (region.isEmpty ()) // nothing to do
 	return;
 
-    GLWindow::Geometry &geometry = GLWindow::get (mWindow)->geometry ();
-
-    for (unsigned int it = 0; it < nMatrix; it++)
-    {
-	if (matrix[it].xy != 0.0f || matrix[it].yx != 0.0f)
-	{
-	    rect = false;
-	    break;
-	}
-    }
-
     CompRect outRect (mAWindow->savedRectsValid () ?
 		      mAWindow->savedOutRect () :
 		      mWindow->outputRect ());
@@ -262,30 +249,15 @@
     winContentsY = oy + outExtents.top;
     winContentsHeight = oheight - outExtents.top - outExtents.bottom;
 
-    geometry.texUnits = (int)nMatrix;
-
-    if (geometry.vCount == 0)
-    {
-	// reset
-	geometry.indexCount = 0;
-	geometry.texCoordSize = 4;
-    }
-    geometry.vertexStride = 3 + geometry.texUnits * geometry.texCoordSize;
-    vSize = geometry.vertexStride;
-
-    nVertices = geometry.vCount;
-    nIndices = geometry.indexCount;
-
-    v = geometry.vertices + (nVertices * vSize);
-    i = geometry.indices + nIndices;
-
-    // For each clip passed to this function
-    foreach (const CompRect &pClip, region.rects ())
-    {
-	x1 = pClip.x1 ();
-	y1 = pClip.y1 ();
-	x2 = pClip.x2 ();
-	y2 = pClip.y2 ();
+    GLWindow *gWindow = GLWindow::get (mWindow);
+    GLVertexBuffer *vertexBuffer = gWindow->vertexBuffer ();
+    vSize = vertexBuffer->getVertexStride ();
+
+    // Indentation kept to provide a clean diff with the old code, for now...
+    {
+	y1 = outRect.y1 ();
+	x2 = outRect.x2 ();
+	y2 = outRect.y2 ();
 
 	gridW = (float)owidth / (mGridWidth - 1);
 
@@ -310,64 +282,22 @@
 	else
 	    gridH = (float)oheight / (mGridHeight - 1);
 
-	// nVertX, nVertY: number of vertices for this clip in x and y dimensions
-	// + 2 to avoid running short of vertices in some cases
-	nVertX = ceil ((x2 - x1) / gridW) + 2;
-	nVertY = (gridH ? ceil ((y2 - y1) / gridH) : 0) + 2;
-
-	// Allocate 4 indices for each quad
-	int newIndexSize = nIndices + ((nVertX - 1) * (nVertY - 1) * 4);
-
-	if (newIndexSize > geometry.indexSize)
-	{
-	    if (!geometry.moreIndices (newIndexSize))
-		return;
-
-	    i = geometry.indices + nIndices;
-	}
-	// Assign quad vertices to indices
-	for (int jy = 0; jy < nVertY - 1; jy++)
-	{
-	    for (int jx = 0; jx < nVertX - 1; jx++)
-	    {
-		*i++ = nVertices + nVertX * (2 * jy + 1) + jx;
-		*i++ = nVertices + nVertX * (2 * jy + 1) + jx + 1;
-		*i++ = nVertices + nVertX * 2 * jy + jx + 1;
-		*i++ = nVertices + nVertX * 2 * jy + jx;
-
-		nIndices += 4;
-	    }
-	}
-
-	// Allocate vertices
-	int newVertexSize =
-	    (nVertices + nVertX * (2 * nVertY - 2)) * vSize;
-	if (newVertexSize > geometry.vertexSize)
-	{
-	    if (!geometry.moreVertices (newVertexSize))
-		return;
-
-	    v = geometry.vertices + (nVertices * vSize);
-	}
-
-	float rowTexCoordQ = 1;
-	float prevRowCellWidth = 0;	// this initial value won't be used
-	float rowCellWidth = 0;
-	int clipRowSize = nVertX * vSize;
-
+	int oldCount = vertexBuffer->countVertices ();
+	gWindow->glAddGeometry (matrix, region, clip, gridW, gridH);
+	int newCount = vertexBuffer->countVertices ();
+	v = vertexBuffer->getVertices () + (oldCount * vSize);
+	vMax = vertexBuffer->getVertices () + (newCount * vSize);
+ 
 	// For each vertex
-	float y = y1;
-	for (int jy = 0; jy < nVertY; jy++)
+	for (; v < vMax; v += vSize)
 	{
+	    float x = v[0];
+	    float y = v[1];
 	    float topiyFloat;
-	    bool applyOffsets = true;
 
 	    if (y > y2)
 		y = y2;
 
-	    // Do calculations for y here to avoid repeating
-	    // them unnecessarily in the x loop
-
 	    if (mCurWindowEvent == WindowEventShade ||
 		mCurWindowEvent == WindowEventUnshade)
 	    {
@@ -375,7 +305,6 @@
 		{
 		    topiyFloat = (y - oy) / mDecorTopHeight;
 		    topiyFloat = MIN (topiyFloat, 0.999);	// avoid 1.0
-		    applyOffsets = false;
 		}
 		else if (y2 > winContentsY + winContentsHeight)	// if at bottom
 		{
@@ -383,7 +312,6 @@
 			(mDecorBottomHeight ? (y - winContentsY -
 					       winContentsHeight) /
 			 mDecorBottomHeight : 0);
-		    applyOffsets = false;
 		}
 		else		// in window contents (only in Y coords)
 		{
@@ -406,8 +334,7 @@
 
 	    // End of calculations for y
 
-	    float x = x1;
-	    for (int jx = 0; jx < nVertX; jx++)
+	    // Indentation kept to provide a clean diff with the old code...
 	    {
 		if (x > x2)
 		    x = x2;
@@ -461,179 +388,19 @@
 		deformedY = inyRest * hor1y + iny * hor2y;
 		deformedZ = inyRest * hor1z + iny * hor2z;
 
-		// Texture coordinates (s, t, r, q)
-
-		if (mUseQTexCoord)
-		{
-		    if (jx == 1)
-			rowCellWidth = deformedX - v[-3];
-
-		    // do only once per row for all rows except row 0
-		    if (jy > 0 && jx == 1)
-		    {
-			rowTexCoordQ = (rowCellWidth / prevRowCellWidth);
-
-			for (unsigned int it = 0; it < nMatrix; it++, v += 4)
-			{
-			    // update first column
-			    // (since we didn't know rowTexCoordQ before)
-			    v[-vSize]     *= rowTexCoordQ; // multiply s & t by q
-			    v[-vSize + 1] *= rowTexCoordQ;
-			    v[-vSize + 3] = rowTexCoordQ;  // copy q
-			}
-			v -= nMatrix * 4;
-		    }
-		}
-
-		// Loop for each texture element
-		// (4 texture coordinates for each one)
-		for (unsigned int it = 0; it < nMatrix; it++, v += 4)
-		{
-		    float offsetY = 0;
-
-		    if (rect)
-		    {
-			if (applyOffsets && y < y2)
-			    offsetY = objToTopLeft->mOffsetTexCoordForQuadAfter.y ();
-			v[0] = COMP_TEX_COORD_X (matrix[it], x); // s
-			v[1] = COMP_TEX_COORD_Y (matrix[it], y + offsetY); // t
-		    }
-		    else
-		    {
-			if (applyOffsets && y < y2)
-			    // FIXME:
-			    // The correct y offset below produces wrong
-			    // texture coordinates for some reason.
-			    offsetY = 0;
-			    // offsetY = objToTopLeft->offsetTexCoordForQuadAfter.y;
-			v[0] = COMP_TEX_COORD_XY (matrix[it], x, y + offsetY); // s
-			v[1] = COMP_TEX_COORD_YX (matrix[it], x, y + offsetY); // t
-		    }
-		    v[2] = 0; // r
-
-		    if (0 < jy && jy < nVertY - 1)
-		    {
-			// copy s, t, r to duplicate row
-			memcpy (v + clipRowSize, v, 3 * sizeof (GLfloat));
-			v[3 + clipRowSize] = 1; // q
-		    }
-
-		    if (applyOffsets &&
-			objToTopLeft->mOffsetTexCoordForQuadBefore.y () != 0)
-		    {
-			// After copying to next row, update texture y coord
-			// by following object's offset
-			offsetY = objToTopLeft->mOffsetTexCoordForQuadBefore.y ();
-			if (rect)
-			{
-			    v[1] = COMP_TEX_COORD_Y (matrix[it], y + offsetY);
-			}
-			else
-			{
-			    v[0] = COMP_TEX_COORD_XY (matrix[it],
-						      x, y + offsetY);
-			    v[1] = COMP_TEX_COORD_YX (matrix[it],
-						      x, y + offsetY);
-			}
-		    }
-		    if (mUseQTexCoord)
-		    {
-			v[3] = rowTexCoordQ; // q
-
-			if (jx > 0)	// since column 0 is updated when jx == 1
-			{
-			    // multiply s & t by q
-			    v[0] *= rowTexCoordQ;
-			    v[1] *= rowTexCoordQ;
-			}
-		    }
-		    else
-		    {
-			v[3] = 1; // q
-		    }
-		}
-
 		v[0] = deformedX;
 		v[1] = deformedY;
 		v[2] = deformedZ;
 
-		// Copy vertex coordinates to duplicate row
-		if (0 < jy && jy < nVertY - 1)
-		    memcpy (v + clipRowSize, v, 3 * sizeof (GLfloat));
-
-		nVertices++;
-
-		// increment x properly (so that coordinates fall on grid intersections)
-		x = rightix * gridW + ox;
-
-		v += 3; // move on to next vertex
-	    }
-	    if (mUseQTexCoord)
-		prevRowCellWidth = rowCellWidth;
-
-	    if (0 < jy && jy < nVertY - 1)
-	    {
-		v += clipRowSize;	// skip the duplicate row
-		nVertices += nVertX;
-	    }
-	    // increment y properly (so that coordinates fall on grid intersections)
-	    if (mCurWindowEvent == WindowEventShade ||
-		mCurWindowEvent == WindowEventUnshade)
-	    {
-		y += gridH;
-	    }
-	    else
-	    {
-		y = bottomiy * gridH + oy;
 	    }
 	}
     }
-    geometry.vCount = nVertices;
-    geometry.indexCount = nIndices;
 }
 
 void
 GridAnim::drawGeometry ()
 {
-    GLWindow::Geometry &geometry = GLWindow::get (mWindow)->geometry ();
-
-    int     texUnit = geometry.texUnits;
-    int     currentTexUnit = 0;
-    int     stride = geometry.vertexStride;
-    GLfloat *vertices = geometry.vertices + (stride - 3);
-
-    stride *= (int) sizeof (GLfloat);
-
-    glVertexPointer (3, GL_FLOAT, stride, vertices);
-
-    while (texUnit--)
-    {
-	if (texUnit != currentTexUnit)
-	{
-	    (*GL::clientActiveTexture) ((GLenum)(GL_TEXTURE0_ARB + texUnit));
-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-	    currentTexUnit = texUnit;
-	}
-	vertices -= geometry.texCoordSize;
-	glTexCoordPointer (geometry.texCoordSize,
-			   GL_FLOAT, stride, vertices);
-    }
-
-    glDrawElements (GL_QUADS, geometry.indexCount,
-		    GL_UNSIGNED_SHORT, geometry.indices);
-
-    // disable all texture coordinate arrays except 0
-    texUnit = geometry.texUnits;
-    if (texUnit > 1)
-    {
-	while (--texUnit)
-	{
-	    (*GL::clientActiveTexture) ((GLenum)(GL_TEXTURE0_ARB + texUnit));
-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-	}
-
-	(*GL::clientActiveTexture) (GL_TEXTURE0_ARB);
-    }
+    // Deprecated
 }
 
 GridTransformAnim::GridTransformAnim (CompWindow *w,

=== modified file 'plugins/animation/src/private.h'
--- plugins/animation/src/private.h	2012-05-27 04:32:55 +0000
+++ plugins/animation/src/private.h	2012-08-22 06:16:22 +0000
@@ -407,9 +407,9 @@
     void glAddGeometry (const GLTexture::MatrixList &,
 			const CompRegion &, const CompRegion &,
 			unsigned int = MAXSHORT, unsigned int = MAXSHORT);
-    void glDrawTexture (GLTexture *texture, GLFragment::Attrib &,
-			unsigned int);
-    void glDrawGeometry ();
+    void glDrawTexture (GLTexture *texture, const GLMatrix &,
+                        const GLWindowPaintAttrib &, unsigned int);
+    //void glDrawGeometry ();
 };
 
 class RollUpAnim :

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

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

=== modified file 'plugins/clone/src/clone.cpp'
--- plugins/clone/src/clone.cpp	2012-07-30 09:20:41 +0000
+++ plugins/clone/src/clone.cpp	2012-08-22 06:16:22 +0000
@@ -295,9 +295,6 @@
 			 0.0f);
 	sTransform.scale (zoomX, zoomY, 1.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-
 	filter = gScreen->textureFilter ();
 
 	if (offset == 0.0f)
@@ -325,8 +322,6 @@
 	}
 
 	gScreen->setTextureFilter (filter);
-
-	glPopMatrix ();
     }
 
     return status;

=== modified file 'plugins/compiztoolbox/src/compiztoolbox.cpp'
--- plugins/compiztoolbox/src/compiztoolbox.cpp	2012-07-30 11:20:17 +0000
+++ plugins/compiztoolbox/src/compiztoolbox.cpp	2012-08-22 06:16:22 +0000
@@ -465,9 +465,7 @@
 	sAttrib.yTranslate = wy - g.y () +
 			     window->border ().top  * sAttrib.yScale;
 
-	GLFragment::Attrib fragment (sAttrib);
-
-	if (window->alpha () || fragment.getOpacity () != OPAQUE)
+	if (window->alpha () || sAttrib.opacity != OPAQUE)
 	    mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
 
 	wTransform.translate (g.x (), g.y (), 0.0f);
@@ -476,9 +474,6 @@
 			      sAttrib.yTranslate / sAttrib.yScale - g.y (),
 			      0.0f);
 
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.getMatrix ());
-
 	filter = gScreen->textureFilter ();
 
 	if (baseScreen->getMipmap ())
@@ -488,13 +483,11 @@
 	   very ugly but necessary until the vertex stage has been made
 	   fully pluggable. */
 	gWindow->glAddGeometrySetCurrentIndex (MAXSHORT);
-	gWindow->glDraw (wTransform, fragment, infiniteRegion, mask);
+	gWindow->glDraw (wTransform, sAttrib, infiniteRegion, mask);
 	gWindow->glAddGeometrySetCurrentIndex (addWindowGeometryIndex);
 
 	gScreen->setTextureFilter (filter);
 
-	glPopMatrix ();
-
 	if (iconMode != HideIcon)
 	{
 	    icon = gWindow->getIcon (MAX_ICON_SIZE, MAX_ICON_SIZE);
@@ -535,15 +528,14 @@
 	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)
+	if (gWindow->vertexBuffer ()->end ())
 	{
-	    GLFragment::Attrib fragment (sAttrib);
 	    GLMatrix           wTransform (transform);
 
 	    wTransform.translate (g.x (), g.y (), 0.0f);
@@ -552,12 +544,7 @@
 				  sAttrib.yTranslate / sAttrib.yScale - g.y (),
 				  0.0f);
 
-	    glPushMatrix ();
-	    glLoadMatrixf (wTransform.getMatrix ());
-
-	    gWindow->glDrawTexture (icon, fragment, mask);
-
-	    glPopMatrix ();
+	    gWindow->glDrawTexture (icon, wTransform, sAttrib, mask);
 	}
     }
 }

=== modified file 'plugins/copytex/src/copytex.cpp'
--- plugins/copytex/src/copytex.cpp	2012-06-24 10:12:15 +0000
+++ plugins/copytex/src/copytex.cpp	2012-08-22 06:16:22 +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/include/cube/cube.h'
--- plugins/cube/include/cube/cube.h	2012-01-18 16:26:45 +0000
+++ plugins/cube/include/cube/cube.h	2012-08-22 06:16:22 +0000
@@ -62,15 +62,18 @@
 	virtual void cubePaintTop (const GLScreenPaintAttrib &sAttrib,
 				   const GLMatrix            &transform,
 				   CompOutput                *output,
-				   int                       size);
+				   int                       size,
+				   const GLVector            &normal);
 	virtual void cubePaintBottom (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size);
+				      int                       size,
+				      const GLVector            &normal);
 	virtual void cubePaintInside (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
-				      int                       size);
+				      int                       size,
+				      const GLVector            &normal);
 	virtual bool cubeCheckOrientation (const GLScreenPaintAttrib &sAttrib,
 					   const GLMatrix            &transform,
 					   CompOutput                *output,
@@ -120,13 +123,13 @@
 		      float, float);
 	WRAPABLE_HND (2, CubeScreenInterface, void, cubePaintTop,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (3, CubeScreenInterface, void, cubePaintBottom,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (4, CubeScreenInterface, void, cubePaintInside,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
-		      CompOutput *, int);
+		      CompOutput *, int, const GLVector &);
 	WRAPABLE_HND (5, CubeScreenInterface, bool, cubeCheckOrientation,
 		      const GLScreenPaintAttrib &, const GLMatrix &,
 		      CompOutput *, std::vector<GLVector> &);

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

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2012-08-03 10:12:25 +0000
+++ plugins/decor/src/decor.cpp	2012-08-22 06:16:22 +0000
@@ -153,14 +153,12 @@
 
 bool
 DecorWindow::glDraw (const GLMatrix     &transform,
-		     GLFragment::Attrib &attrib,
+		     const GLWindowPaintAttrib &attrib,
 		     const CompRegion   &region,
 		     unsigned int       mask)
 {
     bool status;
 
-    status = gWindow->glDraw (transform, attrib, region, mask);
-
     /* Don't render dock decorations (shadows) on just any old window */
     if (!(window->type () & CompWindowTypeDockMask))
     {
@@ -188,25 +186,26 @@
 		     */
 		    pmask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
 
-		    if (d->gWindow->glPaint (d->gWindow->paintAttrib (),
+		    const GLWindowPaintAttrib &pAttrib (d->gWindow->paintAttrib ());
+
+		    if (d->gWindow->glPaint (pAttrib,
 					     transform,
 					     region,
 					     pmask))
-		    {
-			GLFragment::Attrib fa (d->gWindow->paintAttrib ());
-			d->glDecorate (transform, fa, region, mask);
-		    }
+			d->glDecorate (transform, pAttrib, region, mask);
 		}
 	    }
 	}
     }
 
+    status = gWindow->glDraw (transform, attrib, region, mask);
+
     return status;
 }
 
 void
 DecorWindow::glDecorate (const GLMatrix     &transform,
-		         GLFragment::Attrib &attrib,
+			 const GLWindowPaintAttrib &attrib,
 		         const CompRegion   &region,
 		         unsigned int       mask)
 {
@@ -217,6 +216,7 @@
 	GLTexture::MatrixList ml (1);
 	mask |= PAINT_WINDOW_BLEND_MASK;
 
+	gWindow->vertexBuffer ()->begin ();
 	const CompRegion *preg = NULL;
 
 	if ((mask & (PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK |
@@ -228,11 +228,8 @@
 	{
 	    tmpRegion = mOutputRegion;
 	    tmpRegion &= region;
-
-	    if (tmpRegion.isEmpty ())
-		preg = &region;
-	    else
-		preg = &shadowRegion;
+	    tmpRegion &= shadowRegion;
+	    preg = &tmpRegion;
 	}
 	else
 	    preg = &region;
@@ -243,8 +240,6 @@
 
 	const CompRegion &reg (*preg);
 
-	gWindow->geometry ().reset ();
-
 	if (updateMatrix)
 	    updateDecorationScale ();
 
@@ -263,9 +258,13 @@
 	    }
 	}
 
-	if (gWindow->geometry ().vCount)
-	    gWindow->glDrawTexture (wd->decor->texture->textures[0],
+	if (gWindow->vertexBuffer ()->end ())
+	{
+	    glEnable (GL_BLEND);
+	    gWindow->glDrawTexture (wd->decor->texture->textures[0], transform,
 				    attrib, mask);
+	    glDisable (GL_BLEND);
+	}
     }
     else if (wd && wd->decor->type == WINDOW_DECORATION_TYPE_WINDOW)
     {
@@ -279,14 +278,16 @@
 	if (updateMatrix)
 	    updateDecorationScale ();
 
+	glEnable (GL_BLEND);
+
 	if (gWindow->textures ().size () == 1)
 	{
 	    ml[0] = gWindow->matrices ()[0];
-	    gWindow->geometry ().reset ();
+	    gWindow->vertexBuffer ()->begin ();
 	    gWindow->glAddGeometry (ml, window->frameRegion (), region);
-
-	    if (gWindow->geometry ().vCount)
-		gWindow->glDrawTexture (gWindow->textures ()[0], attrib, mask);
+	    if (gWindow->vertexBuffer ()->end ())
+		gWindow->glDrawTexture (gWindow->textures ()[0], transform,
+		                        attrib, mask);
 	}
 	else
 	{
@@ -295,14 +296,15 @@
 	    for (unsigned int i = 0; i < gWindow->textures ().size (); i++)
 	    {
 		ml[0] = gWindow->matrices ()[i];
-		gWindow->geometry ().reset ();
+		gWindow->vertexBuffer ()->begin ();
 		gWindow->glAddGeometry (ml, regions[i], region);
-
-		if (gWindow->geometry ().vCount)
-		    gWindow->glDrawTexture (gWindow->textures ()[i], attrib,
-					    mask);
+		if (gWindow->vertexBuffer ()->end ())
+		    gWindow->glDrawTexture (gWindow->textures ()[i], transform,
+		                            attrib, mask);
 	    }
 	}
+
+	glDisable (GL_BLEND);
     }
 }
 

=== modified file 'plugins/decor/src/decor.h'
--- plugins/decor/src/decor.h	2012-05-10 15:40:25 +0000
+++ plugins/decor/src/decor.h	2012-08-22 06:16:22 +0000
@@ -276,9 +276,9 @@
 
 	bool damageRect (bool, const CompRect &);
 
-	bool glDraw (const GLMatrix &, GLFragment::Attrib &,
+	bool glDraw (const GLMatrix &, const GLWindowPaintAttrib &,
 		     const CompRegion &, unsigned int);
-	void glDecorate (const GLMatrix &, GLFragment::Attrib &,
+	void glDecorate (const GLMatrix &, const GLWindowPaintAttrib &,
 		         const CompRegion &, unsigned int);
 
 	void windowNotify (CompWindowNotify n);

=== modified file 'plugins/expo/CMakeLists.txt'
--- plugins/expo/CMakeLists.txt	2012-08-09 20:14:36 +0000
+++ plugins/expo/CMakeLists.txt	2012-08-22 06:16:22 +0000
@@ -1,11 +1,7 @@
 find_package (Compiz REQUIRED)
-include (FindOpenGL)
 include (CompizPlugin)
 
-if (OPENGL_GLU_FOUND)
-    add_subdirectory (src/click_threshold)
-    include_directories (src/click_threshold/include)
-
-    compiz_plugin (expo PLUGINDEPS composite opengl LIBRARIES ${OPENGL_glu_LIBRARY} compiz_expo_click_threshold INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
-
+add_subdirectory (src/click_threshold)
+include_directories (src/click_threshold/include)
+
+compiz_plugin (expo PLUGINDEPS composite opengl LIBRARIES compiz_expo_click_threshold)

=== modified file 'plugins/expo/src/expo.cpp'
--- plugins/expo/src/expo.cpp	2012-08-16 17:00:05 +0000
+++ plugins/expo/src/expo.cpp	2012-08-22 06:16:22 +0000
@@ -4,12 +4,14 @@
  *
  * expo.c
  *
+ * Copyright (c) 2011 Linaro Limited
  * Copyright (c) 2008 Dennis Kasprzyk <[e-mail]>
  * Copyright (c) 2006 Robert Carr <[e-mail]>
  *
  * Authors:
  * Robert Carr <[e-mail]>
  * Dennis Kasprzyk <[e-mail]>
+ * Travis Watkins <[e-mail]>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -26,7 +28,9 @@
 #include "expo.h"
 #include "click-threshold.h"
 #include <math.h>
+#ifndef USE_GLES
 #include <GL/glu.h>
+#endif
 #include <X11/cursorfont.h>
 
 COMPIZ_PLUGIN_20090315 (expo, ExpoPluginVTable);
@@ -641,6 +645,55 @@
     }
 }
 
+static bool
+unproject (float winx, float winy, float winz,
+           const GLMatrix &modelview,
+           const GLMatrix &projection,
+           const GLint viewport[4],
+           float *objx, float *objy, float *objz)
+{
+    GLMatrix finalMatrix = projection * modelview;
+    float in[4], out[4];
+
+    if (!finalMatrix.invert ())
+	return false;
+
+    in[0] = winx;
+    in[1] = winy;
+    in[2] = winz;
+    in[3] = 1.0;
+
+    /* Map x and y from window coordinates */
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+
+    /* Map to range -1 to 1 */
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    for (int i = 0; i < 4; i++)
+    {
+	out[i] = in[0] * finalMatrix[i] +
+	         in[1] * finalMatrix[4  + i] +
+	         in[2] * finalMatrix[8  + i] +
+	         in[3] * finalMatrix[12 + i];
+    }
+
+    if (out[3] == 0.0)
+	return false;
+
+    out[0] /= out[3];
+    out[1] /= out[3];
+    out[2] /= out[3];
+
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+
+    return true;
+}
+
 void
 ExpoScreen::invertTransformedVertex (const GLScreenPaintAttrib& attrib,
 				     const GLMatrix&            transform,
@@ -648,8 +701,7 @@
 				     int                        vertex[2])
 {
     GLMatrix sTransform (transform);
-    GLdouble p1[3], p2[3], v[3], alpha;
-    GLdouble mvm[16], pm[16];
+    float    p1[3], p2[3], v[3], alpha;
     GLint    viewport[4];
     int      i;
 
@@ -657,16 +709,13 @@
     sTransform.toScreenSpace (output, -attrib.zTranslate);
 
     glGetIntegerv (GL_VIEWPORT, viewport);
-    for (i = 0; i < 16; i++)
-    {
-	mvm[i] = sTransform[i];
-	pm[i]  = gScreen->projectionMatrix ()[i];
-    }
 
-    gluUnProject (vertex[0], screen->height () - vertex[1], 0, mvm, pm,
-		  viewport, &p1[0], &p1[1], &p1[2]);
-    gluUnProject (vertex[0], screen->height () - vertex[1], -1.0, mvm, pm,
-		  viewport, &p2[0], &p2[1], &p2[2]);
+    unproject (vertex[0], screen->height () - vertex[1], 0,
+               sTransform, *gScreen->projectionMatrix (), viewport,
+               &p1[0], &p1[1], &p1[2]);
+    unproject (vertex[0], screen->height () - vertex[1], -1.0,
+               sTransform, *gScreen->projectionMatrix (), viewport,
+               &p2[0], &p2[1], &p2[2]);
 
     for (i = 0; i < 3; i++)
 	v[i] = p1[i] - p2[i];
@@ -720,6 +769,8 @@
 		       unsigned int               mask,
 		       bool                       reflection)
 {
+    GLfloat vertexData[12];
+    GLushort colorData[16];
     GLMatrix sTransformW, sTransform (transform);
     int      i, j, vp;
     GLenum   oldFilter = gScreen->textureFilter ();
@@ -740,6 +791,8 @@
     int      glPaintTransformedOutputIndex =
 	gScreen->glPaintTransformedOutputGetCurrentIndex ();
 
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+
     // Make sure that the base glPaintTransformedOutput function is called
     gScreen->glPaintTransformedOutputSetCurrentIndex (MAXSHORT);
 
@@ -832,7 +885,7 @@
     /* zoom out */
     oScale = DEFAULT_Z_CAMERA / (cam[GLVector::z] + DEFAULT_Z_CAMERA);
     sTransform.scale (oScale, oScale, oScale);
-    glNormal3f (0.0, 0.0, -oScale);
+//    glNormal3f (0.0, 0.0, -oScale);
     sTransform.translate (-cam[GLVector::x], -cam[GLVector::y],
 			  -cam[GLVector::z] - DEFAULT_Z_CAMERA);
 
@@ -967,73 +1020,169 @@
 	sTransform.translate (0.0, -(sy + gapY), 0.0f);
     }
 
-    glNormal3f (0.0, 0.0, -1.0);
+//    glNormal3f (0.0, 0.0, -1.0);
 
     if (reflection)
     {
 	glEnable (GL_BLEND);
 	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	glPushMatrix ();
-
 	if (optionGetDeform () != DeformCurve)
 	{
-	    glLoadMatrixf (sTransformW.getMatrix ());
-
-	    glBegin (GL_QUADS);
-	    glColor4f (0.0, 0.0, 0.0, 1.0);
-	    glVertex2f (0.0, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.5);
-	    glVertex2f (0.0, -vpSize.y () * (sy + gapY));
-	    glVertex2f (vpSize.x () * sx * (1.0 + gapX),
-			-vpSize.y () * sy * (1.0 + gapY));
-	    glColor4f (0.0, 0.0, 0.0, 1.0);
-	    glVertex2f (vpSize.x () * sx * (1.0 + gapX), 0.0);
-	    glEnd ();
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = 65535;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = 32768;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = 65535;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = 32768;
+
+	    vertexData[0]  = 0;
+	    vertexData[1]  = 0;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0;
+	    vertexData[4]  = -vpSize.y () * (sy + gapY);
+	    vertexData[5]  = 0;
+	    vertexData[6]  = vpSize.x () * sx * (1.0 + gapX);
+	    vertexData[7]  = 0;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = vpSize.x () * sx * (1.0 + gapX);
+	    vertexData[10] = -vpSize.y () * sy * (1.0 + gapY);
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (sTransformW);
 	}
 	else
 	{
+	    GLMatrix cTransform;
+	    cTransform.translate (0.0, 0.0, -DEFAULT_Z_CAMERA);
+
 	    glCullFace (GL_BACK);
-	    glLoadIdentity ();
-	    glTranslatef (0.0, 0.0, -DEFAULT_Z_CAMERA);
-
-	    glBegin (GL_QUADS);
-	    glColor4f (0.0, 0.0, 0.0, 1.0 * expoCam);
-	    glVertex2f (-0.5, -0.5);
-	    glVertex2f (0.5, -0.5);
-	    glColor4f (0.0, 0.0, 0.0, 0.5 * expoCam);
-	    glVertex2f (0.5, 0.0);
-	    glVertex2f (-0.5, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.5 * expoCam);
-	    glVertex2f (-0.5, 0.0);
-	    glVertex2f (0.5, 0.0);
-	    glColor4f (0.0, 0.0, 0.0, 0.0);
-	    glVertex2f (0.5, 0.5);
-	    glVertex2f (-0.5, 0.5);
-	    glEnd ();
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = (1.0 * expoCam) * 65535;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = (1.0 * expoCam) * 65535;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = (0.5 * expoCam) * 65535;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = (0.5 * expoCam) * 65535;
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = -0.5;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = -0.5;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = 0;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = 0;
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (cTransform);
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    colorData[0]  = 0;
+	    colorData[1]  = 0;
+	    colorData[2]  = 0;
+	    colorData[3]  = (0.5 * expoCam) * 65535;
+	    colorData[4]  = 0;
+	    colorData[5]  = 0;
+	    colorData[6]  = 0;
+	    colorData[7]  = (0.5 * expoCam) * 65535;
+	    colorData[8]  = 0;
+	    colorData[9]  = 0;
+	    colorData[10] = 0;
+	    colorData[11] = 0;
+	    colorData[12] = 0;
+	    colorData[13] = 0;
+	    colorData[14] = 0;
+	    colorData[15] = 0;
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = 0;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = 0;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = 0.5;
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = 0.5;
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (4, colorData);
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (cTransform);
 	}
 	glCullFace (GL_BACK);
 
-	glLoadIdentity ();
-	glTranslatef (0.0, 0.0, -DEFAULT_Z_CAMERA);
-
 	if (optionGetGroundSize () > 0.0)
 	{
-	    glBegin (GL_QUADS);
-	    glColor4usv (optionGetGroundColor1 ());
-	    glVertex2f (-0.5, -0.5);
-	    glVertex2f (0.5, -0.5);
-	    glColor4usv (optionGetGroundColor2 ());
-	    glVertex2f (0.5, -0.5 + optionGetGroundSize ());
-	    glVertex2f (-0.5, -0.5 + optionGetGroundSize ());
-	    glEnd ();
+	    GLMatrix gTransform;
+	    gTransform.translate (0.0, 0.0, -DEFAULT_Z_CAMERA);
+
+	    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	    vertexData[0]  = -0.5;
+	    vertexData[1]  = -0.5;
+	    vertexData[2]  = 0;
+	    vertexData[3]  = 0.5;
+	    vertexData[4]  = -0.5;
+	    vertexData[5]  = 0;
+	    vertexData[6]  = -0.5;
+	    vertexData[7]  = -0.5 + optionGetGroundSize ();
+	    vertexData[8]  = 0;
+	    vertexData[9]  = 0.5;
+	    vertexData[10] = -0.5 + optionGetGroundSize ();
+	    vertexData[11] = 0;
+
+	    streamingBuffer->addColors (1, optionGetGroundColor1 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor1 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor2 ());
+	    streamingBuffer->addColors (1, optionGetGroundColor2 ());
+	    streamingBuffer->addVertices (4, vertexData);
+
+	    streamingBuffer->end ();
+	    streamingBuffer->render (gTransform);
 	}
-
-	glColor4usv (defaultColor);
-
 	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 	glDisable (GL_BLEND);
-	glPopMatrix ();
     }
 
     expoActive = false;
@@ -1094,14 +1243,14 @@
 
 bool
 ExpoWindow::glDraw (const GLMatrix&     transform,
-		    GLFragment::Attrib& fragment,
+                    const GLWindowPaintAttrib &attrib,
 		    const CompRegion&   region,
 		    unsigned int        mask)
 {
     if (eScreen->expoCam == 0.0f)
-	return gWindow->glDraw (transform, fragment, region, mask);
+	return gWindow->glDraw (transform, attrib, region, mask);
 
-    GLFragment::Attrib fA (fragment);
+    GLWindowPaintAttrib eAttrib (attrib);
     int                expoAnimation;
 
     expoAnimation = eScreen->optionGetExpoAnimation ();
@@ -1109,7 +1258,7 @@
     if (eScreen->expoActive)
     {
 	if (expoAnimation != ExpoScreen::ExpoAnimationZoom)
-	    fA.setOpacity (fragment.getOpacity () * eScreen->expoCam);
+	    eAttrib.opacity = attrib.opacity * eScreen->expoCam;
 
 	if (window->wmType () & CompWindowTypeDockMask &&
 	    eScreen->optionGetHideDocks ())
@@ -1117,28 +1266,28 @@
 	    if (expoAnimation == ExpoScreen::ExpoAnimationZoom &&
 		eScreen->paintingVp == eScreen->selectedVp)
 	    {
-		fA.setOpacity (fragment.getOpacity () *
-			       (1 - sigmoidProgress (eScreen->expoCam)));
+		eAttrib.opacity = attrib.opacity *
+		                      (1 - sigmoidProgress (eScreen->expoCam));
 	    }
 	    else
 	    {
-		fA.setOpacity (0);
+		eAttrib.opacity = 0;
 	    }
 	}
 
-	fA.setBrightness (fragment.getBrightness () * eScreen->vpBrightness);
-	fA.setSaturation (fragment.getSaturation () * eScreen->vpSaturation);
+	eAttrib.brightness = attrib.brightness * eScreen->vpBrightness;
+	eAttrib.saturation = attrib.saturation * eScreen->vpSaturation;
     }
     else
     {
 	if (expoAnimation == ExpoScreen::ExpoAnimationZoom)
-	    fA.setBrightness (0);
+	    eAttrib.brightness = 0;
 	else
-	    fA.setBrightness (fragment.getBrightness () *
-			      (1 - sigmoidProgress (eScreen->expoCam)));
+	    eAttrib.brightness = attrib.brightness *
+	                              (1 - sigmoidProgress (eScreen->expoCam));
     }
 
-    return gWindow->glDraw (transform, fA, region, mask);
+    return gWindow->glDraw (transform, eAttrib, region, mask);
 }
 
 #define EXPO_GRID_SIZE 100
@@ -1154,7 +1303,7 @@
 	screen->desktopWindowCount () &&
 	eScreen->optionGetDeform () == ExpoScreen::DeformCurve)
     {
-	int         i, oldVCount = gWindow->geometry ().vCount;
+	int         i, oldVCount = gWindow->vertexBuffer ()->countVertices ();
 	GLfloat     *v;
 	CompPoint   offset;
 	float       lastX, lastZ = 0.0;
@@ -1165,9 +1314,10 @@
 				MIN(maxGridWidth , EXPO_GRID_SIZE),
 				maxGridHeight);
 
-	v  = gWindow->geometry ().vertices;
-	v += gWindow->geometry ().vertexStride - 3;
-	v += gWindow->geometry ().vertexStride * oldVCount;
+	int stride = gWindow->vertexBuffer ()->getVertexStride ();
+	v  = gWindow->vertexBuffer ()->getVertices ();
+	v += stride - 3;
+	v += stride * oldVCount;
 
 	if (!window->onAllViewports ())
 	{
@@ -1177,7 +1327,7 @@
 
 	lastX = -1000000000.0;
 
-	for (i = oldVCount; i < gWindow->geometry ().vCount; i++)
+	for (i = oldVCount; i < gWindow->vertexBuffer ()->countVertices (); i++)
 	{
 	    if (v[0] == lastX)
 	    {
@@ -1198,7 +1348,7 @@
 	    lastX = v[0];
 	    lastZ = v[2];
 
-	    v += gWindow->geometry ().vertexStride;
+	    v += stride;
 	}
     }
     else
@@ -1209,7 +1359,8 @@
 
 void
 ExpoWindow::glDrawTexture (GLTexture           *texture,
-			   GLFragment::Attrib& attrib,
+                           const GLMatrix            &transform,
+                           const GLWindowPaintAttrib &attrib,
 			   unsigned int        mask)
 {
     if (eScreen->expoCam > 0.0                                 &&
@@ -1217,15 +1368,9 @@
 	eScreen->gScreen->lighting ()                          &&
 	screen->desktopWindowCount ())
     {
-	unsigned int i, idx, vCount;
 	CompPoint    offset;
-	float        x;
 	GLfloat      *v;
-
-	vCount = gWindow->geometry ().vCount;
-
-	if (eScreen->winNormals.size () < vCount * 3)
-	    eScreen->winNormals.resize (vCount * 3);
+	GLVertexBuffer *vb = gWindow->vertexBuffer ();
 
 	if (!window->onAllViewports ())
 	{
@@ -1233,44 +1378,44 @@
 	    offset = window->getMovementForOffset (offset);
 	}
 
-	v = gWindow->geometry ().vertices +
-	    (gWindow->geometry ().vertexStride - 3);
+	int stride = vb->getVertexStride ();
+	v = vb->getVertices () + stride - 3;
 
-	for (i = 0; i < vCount; i++)
+	for (int i = 0; i < vb->countVertices (); i++)
 	{
-	    x = (float) (v[0] + offset.x () - screen->width () / 2) *
-		        eScreen->curveAngle / screen->width ();
+	    float x = (v[0] + offset.x () - screen->width () / 2) *
+		      eScreen->curveAngle / screen->width ();
 
 	    while (x < 0)
 		x += 360.0;
 
-	    idx = floor (x);
-
-	    eScreen->winNormals[i * 3] = -eScreen->vpNormals[idx * 3];
-	    eScreen->winNormals[(i * 3) + 1] =
-		eScreen->vpNormals[(idx * 3) + 1];
-	    eScreen->winNormals[(i * 3) + 2] =
-		eScreen->vpNormals[(idx * 3) + 2];
-
-	    v += gWindow->geometry ().vertexStride;
+	    int idx = floor (x);
+
+	    GLfloat normal[3];
+	    normal[0] = -eScreen->vpNormals[idx * 3];
+	    normal[1] = eScreen->vpNormals[(idx * 3) + 1];
+	    normal[2] = eScreen->vpNormals[(idx * 3) + 2];
+	    vb->addNormals (1, normal);
+
+	    v += stride;
 	}
 
+/* I am not entirely certain if these ifdefs are necessary
+ * since we should be doing normalization in the shader,
+ * however I have them here for now */
+#ifndef USE_GLES
 	glEnable (GL_NORMALIZE);
-	glNormalPointer (GL_FLOAT,0, &eScreen->winNormals.at (0));
-
-	glEnableClientState (GL_NORMAL_ARRAY);
-
-	gWindow->glDrawTexture (texture, attrib, mask);
-
+#endif
+	gWindow->glDrawTexture (texture, transform, attrib, mask);
+#ifndef USE_GLES
 	glDisable (GL_NORMALIZE);
-	glDisableClientState (GL_NORMAL_ARRAY);
-	glNormal3f (0.0, 0.0, -1.0);
+#endif
     }
     else
     {
-	glEnable (GL_NORMALIZE);
-	gWindow->glDrawTexture (texture, attrib, mask);
-	glDisable (GL_NORMALIZE);
+//	glEnable (GL_NORMALIZE);
+	gWindow->glDrawTexture (texture, transform, attrib, mask);
+//	glDisable (GL_NORMALIZE);
     }
 }
 

=== modified file 'plugins/expo/src/expo.h'
--- plugins/expo/src/expo.h	2012-08-09 14:42:56 +0000
+++ plugins/expo/src/expo.h	2012-08-22 06:16:22 +0000
@@ -110,7 +110,6 @@
 	float curveRadius;
 
 	std::vector<GLfloat> vpNormals;
-	std::vector<GLfloat> winNormals;
 
 	CompScreen::GrabHandle grabIndex;
 
@@ -142,15 +141,15 @@
 
 	bool damageRect (bool, const CompRect&);
 
-	bool glDraw (const GLMatrix&, GLFragment::Attrib&,
+	bool glDraw (const GLMatrix&, const GLWindowPaintAttrib&,
 		     const CompRegion&, unsigned int);
 	bool glPaint (const GLWindowPaintAttrib&, const GLMatrix&,
 		      const CompRegion&, unsigned int);
 	void glAddGeometry (const GLTexture::MatrixList&,
 			    const CompRegion&, const CompRegion&,
 			    unsigned int, unsigned int);
-	void glDrawTexture (GLTexture *, GLFragment::Attrib& attrib,
-			    unsigned int);
+	void glDrawTexture (GLTexture*, const GLMatrix&,
+	                    const GLWindowPaintAttrib&, unsigned int);
 
 	CompWindow      *window;
 	CompositeWindow *cWindow;

=== modified file 'plugins/ezoom/src/ezoom.cpp'
--- plugins/ezoom/src/ezoom.cpp	2012-07-29 19:54:31 +0000
+++ plugins/ezoom/src/ezoom.cpp	2012-08-22 06:16:22 +0000
@@ -381,10 +381,13 @@
 		     CompOutput          *output,
 		     CompRect             box)
 {
-    GLMatrix zTransform = transform;
+    GLMatrix zTransform (transform);
     int           x1,x2,y1,y2;
     int		  inx1, inx2, iny1, iny2;
     int	          out = output->id ();
+    GLushort colorData[4];
+    GLfloat  vertexData[12];
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
 
     zTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
     convertToZoomed (out, box.x1 (), box.y1 (), &inx1, &iny1);
@@ -394,23 +397,61 @@
     y1 = MIN (iny1, iny2);
     x2 = MAX (inx1, inx2);
     y2 = MAX (iny1, iny2);
-    glPushMatrix ();
-    glLoadMatrixf (zTransform.getMatrix ());
-    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-    glEnable (GL_BLEND);
-    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x4fff);
-    glRecti (x1,y2,x2,y1);
-    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x9fff);
-    glBegin (GL_LINE_LOOP);
-    glVertex2i (x1, y1);
-    glVertex2i (x2, y1);
-    glVertex2i (x2, y2);
-    glVertex2i (x1, y2);
-    glEnd ();
-    glColor4usv (defaultColor);
-    glDisable (GL_BLEND);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-    glPopMatrix ();
+
+    streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+    colorData[0] = 0x2fff;
+    colorData[1] = 0x2fff;
+    colorData[2] = 0x2fff;
+    colorData[3] = 0x4fff;
+
+    streamingBuffer->addColors (1, colorData);
+
+    vertexData[0]  = x1;
+    vertexData[1]  = y1;
+    vertexData[2]  = 0.0f;
+    vertexData[3]  = x1;
+    vertexData[4]  = y2;
+    vertexData[5]  = 0.0f;
+    vertexData[6]  = x2;
+    vertexData[7]  = y1;
+    vertexData[8]  = 0.0f;
+    vertexData[9]  = x2;
+    vertexData[10] = y2;
+    vertexData[11] = 0.0f;
+
+    streamingBuffer->addVertices (4, vertexData);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (zTransform);
+
+
+    streamingBuffer->begin (GL_LINE_LOOP);
+
+    colorData[0] = 0x2fff;
+    colorData[1] = 0x2fff;
+    colorData[2] = 0x4fff;
+    colorData[3] = 0x9fff;
+
+    streamingBuffer->addColors (1, colorData);
+
+    vertexData[0]  = x1;
+    vertexData[1]  = y1;
+    vertexData[2]  = 0.0f;
+    vertexData[3]  = x2;
+    vertexData[4]  = y1;
+    vertexData[5]  = 0.0f;
+    vertexData[6]  = x2;
+    vertexData[7]  = y2;
+    vertexData[8]  = 0.0f;
+    vertexData[9]  = x1;
+    vertexData[10] = y2;
+    vertexData[11] = 0.0f;
+
+    streamingBuffer->addVertices (4, vertexData);
+
+    streamingBuffer->end ();
+    streamingBuffer->render (zTransform);
 }
 /* Apply the zoom if we are grabbed.
  * Make sure to use the correct filter.
@@ -1060,6 +1101,9 @@
 	GLMatrix      sTransform = transform;
 	float	      scaleFactor;
 	int           ax, ay, x, y;
+	GLfloat         textureData[8];
+	GLfloat         vertexData[12];
+	GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
 
 	/*
 	 * XXX: expo knows how to handle mouse when zoomed, so we back off
@@ -1073,37 +1117,55 @@
 
 	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 	convertToZoomed (out, mouse.x (), mouse.y (), &ax, &ay);
-        glPushMatrix ();
-	glLoadMatrixf (sTransform.getMatrix ());
-	glTranslatef ((float) ax, (float) ay, 0.0f);
+	sTransform.translate ((float) ax, (float) ay, 0.0f);
+
 	if (optionGetScaleMouseDynamic ())
 	    scaleFactor = 1.0f / zooms.at (out).currentZoom;
 	else
 	    scaleFactor = 1.0f / optionGetScaleMouseStatic ();
-	glScalef (scaleFactor,
-		  scaleFactor,
-		  1.0f);
+
+	sTransform.scale (scaleFactor, scaleFactor, 1.0f);
 	x = -cursor.hotX;
 	y = -cursor.hotY;
 
 	glEnable (GL_BLEND);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor.texture);
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
-
-	glBegin (GL_QUADS);
-	glTexCoord2d (0, 0);
-	glVertex2f (x, y);
-	glTexCoord2d (0, cursor.height);
-	glVertex2f (x, y + cursor.height);
-	glTexCoord2d (cursor.width, cursor.height);
-	glVertex2f (x + cursor.width, y + cursor.height);
-	glTexCoord2d (cursor.width, 0);
-	glVertex2f (x + cursor.width, y);
-	glEnd ();
+	glEnable (GL_TEXTURE_2D);
+	glBindTexture (GL_TEXTURE_2D, cursor.texture);
+
+	streamingBuffer->begin (GL_TRIANGLE_STRIP);
+
+	vertexData[0]  = x;
+	vertexData[1]  = y;
+	vertexData[2]  = 0.0f;
+	vertexData[3]  = x;
+	vertexData[4]  = y + cursor.height;
+	vertexData[5]  = 0.0f;
+	vertexData[6]  = x + cursor.width;
+	vertexData[7]  = y;
+	vertexData[8]  = 0.0f;
+	vertexData[9]  = x + cursor.width;
+	vertexData[10] = y + cursor.height;
+	vertexData[11] = 0.0f;
+
+	streamingBuffer->addVertices (4, vertexData);
+
+	textureData[0] = 0;
+	textureData[1] = 0;
+	textureData[2] = 0;
+	textureData[3] = 1;
+	textureData[4] = 1;
+	textureData[5] = 0;
+	textureData[6] = 1;
+	textureData[7] = 1;
+
+	streamingBuffer->addTexCoords (0, 4, textureData);
+
+	streamingBuffer->end ();
+	streamingBuffer->render (sTransform);
+
+	glBindTexture (GL_TEXTURE_2D, 0);
+	glDisable (GL_TEXTURE_2D);
 	glDisable (GL_BLEND);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
-	glDisable (GL_TEXTURE_RECTANGLE_ARB);
-	glPopMatrix ();
     }
 }
 
@@ -1120,16 +1182,20 @@
     {
 	cursor->isSet = true;
 	cursor->screen = screen;
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
+
+	glEnable (GL_TEXTURE_2D);
 	glGenTextures (1, &cursor->texture);
-	glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor->texture);
+	glBindTexture (GL_TEXTURE_2D, cursor->texture);
 
-	glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-			 GL_TEXTURE_WRAP_S, GL_CLAMP);
-	glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-			 GL_TEXTURE_WRAP_T, GL_CLAMP);
-    } else {
-	glEnable (GL_TEXTURE_RECTANGLE_ARB);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+	                 gScreen->textureFilter ());
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
+	                 gScreen->textureFilter ());
+    }
+    else {
+	glEnable (GL_TEXTURE_2D);
     }
 
     XFixesCursorImage *ci = XFixesGetCursorImage (dpy);
@@ -1185,11 +1251,11 @@
 	compLogMessage ("ezoom", CompLogLevelWarn, "unable to get system cursor image!");
     }
 
-    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, cursor->texture);
-    glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, cursor->width,
+    glBindTexture (GL_TEXTURE_2D, cursor->texture);
+    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, cursor->width,
 		  cursor->height, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
-    glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
-    glDisable (GL_TEXTURE_RECTANGLE_ARB);
+    glBindTexture (GL_TEXTURE_2D, 0);
+    glDisable (GL_TEXTURE_2D);
 	
     free (pixels);
 }

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

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

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

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

=== modified file 'plugins/mag/src/mag.cpp'
--- plugins/mag/src/mag.cpp	2012-05-27 04:32:55 +0000
+++ plugins/mag/src/mag.cpp	2012-08-22 06:16:22 +0000
@@ -38,7 +38,9 @@
 
     if (program)
     {
+#if 0
 	GL::deletePrograms (1, &program);
+#endif
 	program = 0;
     }
 }
@@ -46,6 +48,7 @@
 bool
 MagScreen::loadFragmentProgram ()
 {
+#if 0
     char  buffer[1024];
     GLsizei bufSize;
     GLint errorPos;
@@ -85,11 +88,14 @@
     GL::bindProgram (GL_FRAGMENT_PROGRAM_ARB, 0);
 
     return true;
+#endif
+    return false;
 }
 
 bool
 MagScreen::loadImages ()
 {
+#if 0
     CompString overlay_s = optionGetOverlay ();
     CompString mask_s = optionGetMask ();
     CompString pname ("mag");
@@ -130,6 +136,8 @@
     }
 
     return true;
+#endif
+    return false;
 }
 
 void
@@ -317,8 +325,6 @@
 
     if (!adjust && zoom == 1.0 && (width || height))
     {
-	glEnable (target);
-
 	glBindTexture (target, texture);
 
 	glTexImage2D (target, 0, GL_RGB, 0, 0, 0,
@@ -328,8 +334,6 @@
 	height = 0;
 	
 	glBindTexture (target, 0);
-
-	glDisable (target);
     }
 
     if (zoom == 1.0 && !adjust)
@@ -357,6 +361,10 @@
     bool           kScreen;
     unsigned short *color;
     float          tmp;
+    GLMatrix       projection;
+    GLMatrix       modelview;
+    GLVertexBuffer *vb = GLVertexBuffer::streamingBuffer ();
+    const GLWindowPaintAttrib attrib = { OPAQUE, BRIGHT, COLOR, 0, 0, 0, 0 };
 
     w = optionGetBoxWidth ();
     h = optionGetBoxHeight ();
@@ -393,8 +401,6 @@
 	ch = h;
     }
 
-    glEnable (target);
-
     glBindTexture (target, texture);
 
     if (width != w || height != h)
@@ -419,13 +425,6 @@
 	ph = 1.0;
     }
 
-    glMatrixMode (GL_PROJECTION);
-    glPushMatrix ();
-    glLoadIdentity ();
-    glMatrixMode (GL_MODELVIEW);
-    glPushMatrix ();
-    glLoadIdentity ();
-
     vc[0] = ((x1 * 2.0) / screen->width ()) - 1.0;
     vc[1] = ((x2 * 2.0) / screen->width ()) - 1.0;
     vc[2] = ((y1 * -2.0) / screen->height ()) + 1.0;
@@ -436,41 +435,63 @@
     tc[2] = h * ph;
     tc[3] = 0.0;
 
-    glColor4usv (defaultColor);
-
-    glPushMatrix ();
-
-    glTranslatef ((float)(posX - (screen->width () / 2)) * 2 / screen->width (),
+    /* Draw zoom box contents */
+    glScissor (x1, screen->height () - y2, w, h);
+
+    glEnable (GL_SCISSOR_TEST);
+
+    modelview.translate ((float)(posX - (screen->width () / 2)) * 2 / screen->width (),
 		  (float)(posY - (screen->height () / 2)) * 2 / -screen->height (), 0.0);
 
-    glScalef (zoom, zoom, 1.0);
+    modelview.scale (zoom, zoom, 1.0);
 
-    glTranslatef ((float)((screen->width () / 2) - posX) * 2 / screen->width (),
+    modelview.translate ((float)((screen->width () / 2) - posX) * 2 / screen->width (),
 		  (float)((screen->height () / 2) - posY) * 2 / -screen->height (), 0.0);
 
-    glScissor (x1, screen->height () - y2, w, h);
-
-    glEnable (GL_SCISSOR_TEST);
-
-    glBegin (GL_QUADS);
-    glTexCoord2f (tc[0], tc[2]);
-    glVertex2f (vc[0], vc[2]);
-    glTexCoord2f (tc[0], tc[3]);
-    glVertex2f (vc[0], vc[3]);
-    glTexCoord2f (tc[1], tc[3]);
-    glVertex2f (vc[1], vc[3]);
-    glTexCoord2f (tc[1], tc[2]);
-    glVertex2f (vc[1], vc[2]);
-    glEnd ();
+    GLfloat vertices[] = {
+	vc[0], vc[2], 0,
+	vc[0], vc[3], 0,
+	vc[1], vc[2], 0,
+	vc[1], vc[3], 0,
+    };
+
+    GLfloat texcoords[] = {
+	tc[0], tc[2],
+	tc[0], tc[3],
+	tc[1], tc[2],
+	tc[1], tc[3],
+    };
+
+    vb->begin (GL_TRIANGLE_STRIP);
+    vb->colorDefault ();
+    vb->addVertices (4, vertices);
+    vb->addTexCoords (0, 4, texcoords);
+    vb->end ();
+
+    vb->render (projection, modelview, attrib);
 
     glDisable (GL_SCISSOR_TEST);
-
-    glPopMatrix ();
-
+    modelview.reset ();
     glBindTexture (target, 0);
 
-    glDisable (target);
-
+    /* Save blending state */
+#if USE_GLES
+    GLboolean isBlendingEnabled = GL_TRUE;
+    GLint blendSrcRGB = GL_ONE;
+    GLint blendSrcAlpha = GL_ONE;
+    GLint blendDstRGB = GL_ZERO;
+    GLint blendDstAlpha = GL_ZERO;
+
+    glGetBooleanv (GL_BLEND, &isBlendingEnabled);
+    glGetIntegerv (GL_BLEND_SRC_RGB, &blendSrcRGB);
+    glGetIntegerv (GL_BLEND_DST_RGB, &blendDstRGB);
+    glGetIntegerv (GL_BLEND_SRC_ALPHA, &blendSrcAlpha);
+    glGetIntegerv (GL_BLEND_DST_ALPHA, &blendDstAlpha);
+#else
+    glPushAttrib (GL_COLOR_BUFFER_BIT);
+#endif
+
+    /* Draw zoom box border */
     glEnable (GL_BLEND);
     glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
@@ -488,40 +509,43 @@
 
     color = optionGetBoxColor ();
 
-    glColor4us (color[0], color[1], color[2], color[3] * tmp);
-
-    glBegin (GL_QUADS);
-    glVertex2f (vc[0] - bw, vc[2] + bh);
-    glVertex2f (vc[0] - bw, vc[2]);
-    glVertex2f (vc[1] + bw, vc[2]);
-    glVertex2f (vc[1] + bw, vc[2] + bh);
-    glVertex2f (vc[0] - bw, vc[3]);
-    glVertex2f (vc[0] - bw, vc[3] - bh);
-    glVertex2f (vc[1] + bw, vc[3] - bh);
-    glVertex2f (vc[1] + bw, vc[3]);
-    glVertex2f (vc[0] - bw, vc[2]);
-    glVertex2f (vc[0] - bw, vc[3]);
-    glVertex2f (vc[0], vc[3]);
-    glVertex2f (vc[0], vc[2]);
-    glVertex2f (vc[1], vc[2]);
-    glVertex2f (vc[1], vc[3]);
-    glVertex2f (vc[1] + bw, vc[3]);
-    glVertex2f (vc[1] + bw, vc[2]);
-    glEnd();
-
-    glColor4usv (defaultColor);
+    GLfloat verticesBorder[] = {
+	vc[0] - bw, vc[2] + bh, 0,
+	vc[0], vc[2], 0,
+	vc[1] + bw, vc[2] + bh, 0,
+	vc[1], vc[2], 0,
+	vc[1] + bw, vc[3] - bh, 0,
+	vc[1], vc[3], 0,
+	vc[0] - bw, vc[3] - bh, 0,
+	vc[0], vc[3], 0,
+	vc[0] - bw, vc[2] + bh, 0,
+	vc[0], vc[2], 0,
+    };
+
+    vb->begin (GL_TRIANGLE_STRIP);
+    vb->color4f (color[0] / 65535.0, color[1] / 65535.0,
+	         color[2] / 65535.0, color[3] * tmp / 65535.0);
+    vb->addVertices (10, verticesBorder);
+    vb->end ();
+
+    vb->render (projection, modelview, attrib);
+
+    vb->colorDefault ();
+
+    /* Restore blending state */
+#if USE_GLES
+    if (!isBlendingEnabled)
     glDisable (GL_BLEND);
-    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-
-    glPopMatrix();
-    glMatrixMode (GL_PROJECTION);
-    glPopMatrix ();
-    glMatrixMode (GL_MODELVIEW);
+    glBlendFuncSeparate (blendSrcRGB, blendDstRGB, blendSrcAlpha, blendDstAlpha);
+#else
+    glPopAttrib ();
+#endif
 }
 
 void
 MagScreen::paintImage ()
 {
+#if 0
     float          pw, ph;
     int            x1, x2, y1, y2;
     float          vc[4];
@@ -680,12 +704,14 @@
     glMatrixMode (GL_MODELVIEW);
 
     glPopAttrib ();
+#endif
 
 }
 
 void
 MagScreen::paintFisheye ()
 {
+#if 0
     float      pw, ph;
     float      radius, fZoom, base; // fZoom is the local zoom variable
     int        x1, x2, y1, y2;
@@ -786,6 +812,7 @@
     glBindTexture (target, 0);
 
     glDisable (target);
+#endif
 }
 
 
@@ -939,12 +966,14 @@
 
     glGenTextures (1, &texture);
 
+#ifdef USE_GLES
+    target = GL_TEXTURE_2D;
+#else
     if (GL::textureNonPowerOfTwo)
 	target = GL_TEXTURE_2D;
     else
 	target = GL_TEXTURE_RECTANGLE_ARB;
-
-    glEnable (target);
+#endif
 
     /* Bind the texture */
     glBindTexture (target, texture);
@@ -952,8 +981,8 @@
     /* Load the parameters */
     glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri (target, GL_TEXTURE_WRAP_S, GL_CLAMP);
-    glTexParameteri (target, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    glTexParameteri (target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri (target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
     glTexImage2D (target, 0, GL_RGB, 0, 0, 0,
 		  GL_RGB, GL_UNSIGNED_BYTE, NULL);
@@ -963,8 +992,6 @@
 
     glBindTexture (target, 0);
 
-    glDisable (target);
-
 #define optionNotify(name)						       \
     optionSet##name##Notify (boost::bind (&MagScreen::optionChanged,	       \
 					    this, _1, _2))
@@ -1004,10 +1031,12 @@
 	mode = MagOptions::ModeSimple;
     }
 
+#if 0
     if (!GL::fragmentProgram)
 	compLogMessage ("mag", CompLogLevelWarn,
 			"GL_ARB_fragment_program not supported. "
 			"Fisheye mode will not work.");
+#endif
 }
 
 MagScreen::~MagScreen ()

=== modified file 'plugins/mag/src/mag.h'
--- plugins/mag/src/mag.h	2012-05-27 04:32:55 +0000
+++ plugins/mag/src/mag.h	2012-08-22 06:16:22 +0000
@@ -161,6 +161,7 @@
 	bool init ();
 };
 
+#if 0
 static const char *fisheyeFpString =
     "!!ARBfp1.0"
 
@@ -190,3 +191,4 @@
     "TEX result.color, t1, texture[0], %s;"
 
     "END";
+#endif

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

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

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

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

=== modified file 'plugins/opengl/CMakeLists.txt'
--- plugins/opengl/CMakeLists.txt	2009-03-15 05:09:18 +0000
+++ plugins/opengl/CMakeLists.txt	2012-08-22 06:16:22 +0000
@@ -2,7 +2,17 @@
 
 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
+set (INTERNAL_LIBRARIES
+     compiz_opengl_double_buffer)
+
+add_subdirectory (src/doublebuffer)
+
+if (USE_GLES)
+    compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD "-DUSE_GLES -std=c++0x" LIBRARIES ${OPENGLES2_LIBRARIES} ${INTERNAL_LIBRARIES} INCDIRS ${OPENGLES2_INCLUDE_DIR})
+else (USE_GLES)
+    find_package (OpenGL)
+    if (OPENGL_FOUND)
+	compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD -std=c++0x LIBRARIES ${OPENGL_gl_LIBRARY} ${INTERNAL_LIBRARIES} INCDIRS ${OPENGL_INCLUDE_DIR})
+    endif (OPENGL_FOUND)
+endif (USE_GLES)
+

=== modified file 'plugins/opengl/compiz-opengl.pc.in'
--- plugins/opengl/compiz-opengl.pc.in	2009-03-15 05:09:18 +0000
+++ plugins/opengl/compiz-opengl.pc.in	2012-08-22 06:16:22 +0000
@@ -8,5 +8,5 @@
 Version: @VERSION@
 
 Requires: compiz compiz-composite
-Libs: -lGL -L${libdir} -lopengl
+Libs: @PKGCONFIG_LIBS@ -L${libdir} -lopengl
 Cflags: @COMPIZ_CFLAGS@ -I${includedir}/compiz
\ No newline at end of file

=== added file 'plugins/opengl/include/opengl/doublebuffer.h'
--- plugins/opengl/include/opengl/doublebuffer.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/doublebuffer.h	2012-08-22 06:16:22 +0000
@@ -0,0 +1,39 @@
+#ifndef _COMPIZ_OPENGL_BUFFERBLIT_H
+#define _COMPIZ_OPENGL_BUFFERBLIT_H
+
+#include <core/region.h>
+
+namespace compiz
+{
+namespace opengl
+{
+
+class DoubleBuffer
+{
+    public:
+	DoubleBuffer ();
+	virtual ~DoubleBuffer ();
+
+	virtual void swap () const = 0;
+	virtual bool blitAvailable () const = 0;
+	virtual void blit (const CompRegion &region) const = 0;
+	virtual bool fallbackBlitAvailable () const = 0;
+	virtual void fallbackBlit (const CompRegion &region) const = 0;
+
+	typedef enum
+	{
+	    VSYNC,
+	    PERSISTENT_BACK_BUFFER,
+	    _NSETTINGS
+	} Setting;
+
+	void set (Setting name, bool value);
+	void render (const CompRegion &region, bool fullscreen);
+
+    protected:
+	bool setting[_NSETTINGS];
+};
+
+}
+}
+#endif

=== removed file 'plugins/opengl/include/opengl/fragment.h'
--- plugins/opengl/include/opengl/fragment.h	2012-01-18 16:26:45 +0000
+++ plugins/opengl/include/opengl/fragment.h	1970-01-01 00:00:00 +0000
@@ -1,125 +0,0 @@
-/*
- * Copyright © 2008 Dennis Kasprzyk
- * Copyright © 2007 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Dennis Kasprzyk not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Dennis Kasprzyk makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Authors: Dennis Kasprzyk <[e-mail]>
- *          David Reveman <[e-mail]>
- */
-
-#ifndef _GLFRAGMENT_H
-#define _GLFRAGMENT_H
-
-#define MAX_FRAGMENT_FUNCTIONS 16
-
-#define COMP_FETCH_TARGET_2D   0
-#define COMP_FETCH_TARGET_RECT 1
-#define COMP_FETCH_TARGET_NUM  2
-
-struct GLWindowPaintAttrib;
-class GLScreen;
-class GLTexture;
-
-/**
- * Describes a texture modification fragment program
- * for a texture
- */
-namespace GLFragment {
-
-    class Storage;
-
-    typedef unsigned int FunctionId;
-
-    class PrivateFunctionData;
-    class PrivateAttrib;
-
-    class FunctionData {
-	public:
-	    FunctionData ();
-	    ~FunctionData ();
-
-	    /**
-	     * Returns the status of this fragment program
-	     * (valid or invalid)
-	     */
-	    bool status ();
-
-	    void addTempHeaderOp (const char *name);
-
-	    void addParamHeaderOp (const char *name);
-
-	    void addAttribHeaderOp (const char *name);
-
-
-	    void addFetchOp (const char *dst, const char *offset, int target);
-
-	    void addColorOp (const char *dst, const char *src);
-
-	    void addDataOp (const char *str, ...);
-
-	    void addBlendOp (const char *str, ...);
-
-	    FunctionId createFragmentFunction (const char *name);
-
-	private:
-	    PrivateFunctionData *priv;
-    };
-
-    class Attrib {
-	public:
-	    Attrib (const GLWindowPaintAttrib &paint);
-	    Attrib (const Attrib&);
-	    ~Attrib ();
-
-	    Attrib &operator= (const Attrib &rhs);
-
-	    unsigned int allocTextureUnits (unsigned int nTexture);
-
-	    unsigned int allocParameters (unsigned int nParam);
-
-	    void addFunction (FunctionId function);
-
-	    bool enable (bool *blending);
-	    void disable ();
-
-	    unsigned short getSaturation ();
-	    unsigned short getBrightness ();
-	    unsigned short getOpacity ();
-
-	    void setSaturation (unsigned short);
-	    void setBrightness (unsigned short);
-	    void setOpacity (unsigned short);
-
-	    bool hasFunctions ();
-
-	private:
-	    PrivateAttrib *priv;
-    };
-
-    void destroyFragmentFunction (FunctionId id);
-
-    FunctionId getSaturateFragmentFunction (GLTexture *texture,
-					    int       param);
-};
-
-
-
-#endif

=== added file 'plugins/opengl/include/opengl/framebufferobject.h'
--- plugins/opengl/include/opengl/framebufferobject.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/framebufferobject.h	2012-08-22 06:16:22 +0000
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2011 Collabora, Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Collabora Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Collabora Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * COLLABORA LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL COLLABORA LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Pekka Paalanen <[e-mail]>
+ */
+
+#ifndef _COMPIZ_GLFRAMEBUFFEROBJECT_H
+#define _COMPIZ_GLFRAMEBUFFEROBJECT_H
+
+#include <opengl/opengl.h>
+
+struct PrivateGLFramebufferObject;
+
+/**
+ * Class representing a framebuffer object in GL, supporting only one
+ * color attachment as per GLES 2 spec. The color attachment is referred
+ * to as the texture (of the FBO).
+ *
+ * Usage:
+ * 1. create a GLFramebufferObject (requires a GL context)
+ * 2. call allocate (size), and check status ()
+ * 3. old = bind ()
+ * 4. do your rendering
+ * 5. rebind (old)
+ * 6. use the rendered texture via tex ()
+ * 7. go to 2 or 3, or delete to quit (requires a GL context)
+ */
+class GLFramebufferObject
+{
+    public:
+	GLFramebufferObject ();
+	~GLFramebufferObject ();
+
+	/**
+	 * Ensure the texture is of the given size, recreating it if needed,
+	 * and replace the FBO color attachment with it. The texture contents
+	 * become undefined, unless specified in the 'image' argument.
+	 * When specifying 'image', it's also possible to pass-in the
+	 * desired image's 'format' and 'type'.
+	 *
+	 * Returns true on success, and false on texture allocation failure.
+	 */
+	bool allocate (const CompSize &size,
+		       const char *image = NULL,
+		       GLenum format = GL_RGBA,
+		       GLenum type = GL_UNSIGNED_BYTE);
+
+	/**
+	 * Bind this as the current FBO, previous binding in GL context is
+	 * undone. GL rendering is now targeted to this FBO.
+	 * Returns a pointer to the previously bound FBO, or NULL if
+	 * the previous binding was zero (the window system provided
+	 * framebuffer).
+	 *
+	 * The previous FBO is no longer bound, so you can use its
+	 * texture. To restore the previous FBO, call rebind (FBO) with
+	 * the returned pointer as the argument.
+	 */
+	GLFramebufferObject *bind ();
+
+	/**
+	 * Bind the given FBO as the current FBO, without looking up the
+	 * previous binding. The argument can be NULL, in which case the
+	 * window system provided framebuffer gets bound (FBO is unbound).
+	 */
+	static void rebind (GLFramebufferObject *fbo);
+
+	/**
+	 * Check the FBO completeness. Returns true on complete.
+	 * Otherwise returns false and reports the error to log.
+	 */
+	bool checkStatus ();
+
+	/**
+	 * Return a pointer to the texture that is the color attachment.
+	 * This will return NULL, if allocate () has not been called, or
+	 * the last allocate () call failed.
+	 */
+	GLTexture *tex ();
+
+    private:
+	PrivateGLFramebufferObject *priv;
+};
+
+#endif // _COMPIZ_GLFRAMEBUFFEROBJECT_H

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

=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2012-01-20 09:05:56 +0000
+++ plugins/opengl/include/opengl/opengl.h	2012-08-22 06:16:22 +0000
@@ -28,16 +28,52 @@
 #ifndef _COMPIZ_OPENGL_H
 #define _COMPIZ_OPENGL_H
 
+#ifdef USE_GLES
+#define SUPPORT_X11
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
 #include <GL/gl.h>
 #include <GL/glx.h>
+#endif
+
+#include <core/size.h>
+#include <core/pluginclasshandler.h>
 
 #include <opengl/matrix.h>
 #include <opengl/texture.h>
-#include <opengl/fragment.h>
-
-#define COMPIZ_OPENGL_ABI 4
-
-#include <core/pluginclasshandler.h>
+#include <opengl/framebufferobject.h>
+#include <opengl/vertexbuffer.h>
+#include <opengl/program.h>
+#include <opengl/programcache.h>
+#include <opengl/shadercache.h>
+
+#define COMPIZ_OPENGL_ABI 5
+
+/*
+ * Some plugins check for #ifdef USE_MODERN_COMPIZ_GL. Support it for now, but
+ * but the offending code should be changed to:  #if COMPIZ_OPENGL_ABI >= 5
+ * Or the preprocessor checks should be removed altogether.
+ */
+#define USE_MODERN_COMPIZ_GL 1
+
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
+
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
 
 /**
  * camera distance from screen, 0.5 * tan (FOV)
@@ -75,8 +111,26 @@
 #endif
 
 namespace GL {
-
+    #ifdef USE_GLES
+    typedef EGLImageKHR (*EGLCreateImageKHRProc)  (EGLDisplay dpy,
+                                                   EGLContext ctx,
+                                                   EGLenum target,
+                                                   EGLClientBuffer buffer,
+                                                   const EGLint *attrib_list);
+    typedef EGLBoolean  (*EGLDestroyImageKHRProc) (EGLDisplay dpy,
+                                                   EGLImageKHR image);
+
+    typedef void (*GLEGLImageTargetTexture2DOESProc) (GLenum target,
+                                                      GLeglImageOES image);
+
+    typedef EGLBoolean (*EGLPostSubBufferNVProc) (EGLDisplay dpy,
+						  EGLSurface surface,
+						  EGLint x, EGLint y,
+						  EGLint width, EGLint height);
+
+    #else
     typedef void (*FuncPtr) (void);
+
     typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
 
     typedef void    (*GLXBindTexImageProc)    (Display	 *display,
@@ -122,11 +176,6 @@
 					      const int   *attribList);
     typedef void      (*GLXDestroyPixmapProc) (Display *display,
     					       GLXPixmap pixmap);
-
-    typedef void (*GLActiveTextureProc) (GLenum texture);
-    typedef void (*GLClientActiveTextureProc) (GLenum texture);
-    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
-
     typedef void (*GLGenProgramsProc) (GLsizei n,
 				       GLuint  *programs);
     typedef void (*GLDeleteProgramsProc) (GLsizei n,
@@ -146,11 +195,16 @@
     typedef void (*GLGetProgramivProc) (GLenum target,
 					GLenum pname,
 					int    *params);
+    #endif
+
+    typedef void (*GLActiveTextureProc) (GLenum texture);
+    typedef void (*GLClientActiveTextureProc) (GLenum texture);
+    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
 
     typedef void (*GLGenFramebuffersProc) (GLsizei n,
 					   GLuint  *framebuffers);
     typedef void (*GLDeleteFramebuffersProc) (GLsizei n,
-					      GLuint  *framebuffers);
+					      const GLuint  *framebuffers);
     typedef void (*GLBindFramebufferProc) (GLenum target,
 					   GLuint framebuffer);
     typedef GLenum (*GLCheckFramebufferStatusProc) (GLenum target);
@@ -161,6 +215,136 @@
 						GLint  level);
     typedef void (*GLGenerateMipmapProc) (GLenum target);
 
+    typedef void (*GLBindBufferProc) (GLenum target,
+                                      GLuint buffer);
+    typedef void (*GLDeleteBuffersProc) (GLsizei n,
+                                         const GLuint *buffers);
+    typedef void (*GLGenBuffersProc) (GLsizei n,
+                                      GLuint *buffers);
+    typedef void (*GLBufferDataProc) (GLenum target,
+                                      GLsizeiptr size,
+                                      const GLvoid *data,
+                                      GLenum usage);
+    typedef void (*GLBufferSubDataProc) (GLenum target,
+                                         GLintptr offset,
+                                         GLsizeiptr size,
+                                         const GLvoid *data);
+
+    typedef void (*GLGetShaderivProc) (GLuint shader,
+                                       GLenum pname,
+                                       GLint *params);
+    typedef void (*GLGetShaderInfoLogProc) (GLuint shader,
+                                            GLsizei bufsize,
+                                            GLsizei *length,
+                                            GLchar *infoLog);
+    typedef void (*GLGetProgramivProc) (GLuint program,
+                                        GLenum pname,
+                                        GLint* params);
+    typedef void (*GLGetProgramInfoLogProc) (GLuint program,
+                                             GLsizei bufsize,
+                                             GLsizei *length,
+                                             GLchar *infoLog);
+    typedef GLuint (*GLCreateShaderProc) (GLenum type);
+    typedef void (*GLShaderSourceProc) (GLuint shader,
+                                        GLsizei count,
+                                        const GLchar **string,
+                                        const GLint* length);
+    typedef void (*GLCompileShaderProc) (GLuint shader);
+    typedef GLuint (*GLCreateProgramProc) ();
+    typedef void (*GLAttachShaderProc) (GLuint program,
+                                        GLuint shader);
+    typedef void (*GLLinkProgramProc) (GLuint program);
+    typedef void (*GLValidateProgramProc) (GLuint program);
+    typedef void (*GLDeleteShaderProc) (GLuint shader);
+    typedef void (*GLDeleteProgramProc) (GLuint program);
+    typedef void (*GLUseProgramProc) (GLuint program);
+    typedef int  (*GLGetUniformLocationProc) (GLuint program,
+                                              const GLchar* name);
+    typedef void (*GLUniform1fProc) (GLint location, GLfloat x);
+    typedef void (*GLUniform1iProc) (GLint location, GLint x);
+    typedef void (*GLUniform2fProc) (GLint location, GLfloat x, GLfloat y);
+    typedef void (*GLUniform3fProc) (GLint location,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z);
+    typedef void (*GLUniform4fProc) (GLint location,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z,
+                                     GLfloat w);
+    typedef void (*GLUniform2iProc) (GLint location, GLint x, GLint y);
+    typedef void (*GLUniform3iProc) (GLint location,
+                                     GLint x,
+                                     GLint y,
+                                     GLint z);
+    typedef void (*GLUniform4iProc) (GLint location,
+                                     GLint x,
+                                     GLint y,
+                                     GLint z,
+                                     GLint w);
+    typedef void (*GLUniformMatrix4fvProc) (GLint location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const GLfloat *value);
+    typedef int (*GLGetAttribLocationProc) (GLuint program,
+                                            const GLchar *name);
+
+    typedef void (*GLEnableVertexAttribArrayProc) (GLuint index);
+    typedef void (*GLDisableVertexAttribArrayProc) (GLuint index);
+    typedef void (*GLVertexAttribPointerProc) (GLuint index,
+                                               GLint size,
+                                               GLenum type,
+                                               GLboolean normalized,
+                                               GLsizei stride,
+                                               const GLvoid *ptr);
+
+    typedef void (*GLGenRenderbuffersProc) (GLsizei n,
+					GLuint  *rb);
+    typedef void (*GLDeleteRenderbuffersProc) (GLsizei n,
+					   const GLuint  *rb);
+    typedef void (*GLBindRenderbufferProc) (GLenum target,
+					GLuint renderbuffer);
+    typedef void (*GLFramebufferRenderbufferProc) (GLenum target,
+					       GLenum attachment,
+					       GLenum renderbuffertarget,
+					       GLuint renderbuffer);
+    typedef void (*GLRenderbufferStorageProc) (GLenum target,
+					   GLenum internalformat,
+					   GLsizei width,
+					   GLsizei height);
+
+
+    /* GL_ARB_shader_objects */
+    #ifndef USE_GLES
+    typedef GLhandleARB (*GLCreateShaderObjectARBProc) (GLenum type);
+    typedef GLhandleARB (*GLCreateProgramObjectARBProc) ();
+    typedef void (*GLShaderSourceARBProc) (GLhandleARB shader,
+                                        GLsizei count,
+                                        const GLchar **string,
+                                        const GLint* length);
+    typedef void (*GLCompileShaderARBProc) (GLhandleARB shader);
+    typedef void (*GLValidateProgramARBProc) (GLhandleARB program);
+    typedef void (*GLDeleteObjectARBProc) (GLhandleARB object);
+    typedef void (*GLAttachObjectARBProc) (GLhandleARB program,
+                                        GLhandleARB shader);
+    typedef void (*GLLinkProgramARBProc) (GLhandleARB program);
+    typedef void (*GLUseProgramObjectARBProc) (GLhandleARB program);
+    typedef int  (*GLGetUniformLocationARBProc) (GLhandleARB program,
+                                              const GLchar* name);
+    typedef int (*GLGetAttribLocationARBProc) (GLhandleARB program,
+                                            const GLchar *name);
+
+    typedef void (*GLGetObjectParameterivProc) (GLhandleARB object, GLenum type, int *param);
+    typedef void (*GLGetInfoLogProc) (GLhandleARB object, int maxLen, int *len, char *log);
+    #endif
+
+    #ifdef USE_GLES
+    extern EGLCreateImageKHRProc  createImage;
+    extern EGLDestroyImageKHRProc destroyImage;
+
+    extern GLEGLImageTargetTexture2DOESProc eglImageTargetTexture;
+
+    #else
     extern GLXBindTexImageProc      bindTexImage;
     extern GLXReleaseTexImageProc   releaseTexImage;
     extern GLXQueryDrawableProc     queryDrawable;
@@ -172,11 +356,6 @@
     extern GLXGetFBConfigAttribProc getFBConfigAttrib;
     extern GLXCreatePixmapProc      createPixmap;
     extern GLXDestroyPixmapProc     destroyPixmap;
-
-    extern GLActiveTextureProc       activeTexture;
-    extern GLClientActiveTextureProc clientActiveTexture;
-    extern GLMultiTexCoord2fProc     multiTexCoord2f;
-
     extern GLGenProgramsProc        genPrograms;
     extern GLDeleteProgramsProc     deletePrograms;
     extern GLBindProgramProc        bindProgram;
@@ -184,6 +363,11 @@
     extern GLProgramParameter4fProc programEnvParameter4f;
     extern GLProgramParameter4fProc programLocalParameter4f;
     extern GLGetProgramivProc       getProgramiv;
+    #endif
+
+    extern GLActiveTextureProc       activeTexture;
+    extern GLClientActiveTextureProc clientActiveTexture;
+    extern GLMultiTexCoord2fProc     multiTexCoord2f;
 
     extern GLGenFramebuffersProc        genFramebuffers;
     extern GLDeleteFramebuffersProc     deleteFramebuffers;
@@ -192,20 +376,177 @@
     extern GLFramebufferTexture2DProc   framebufferTexture2D;
     extern GLGenerateMipmapProc         generateMipmap;
 
+    extern GLBindBufferProc    bindBuffer;
+    extern GLDeleteBuffersProc deleteBuffers;
+    extern GLGenBuffersProc    genBuffers;
+    extern GLBufferDataProc    bufferData;
+    extern GLBufferSubDataProc bufferSubData;
+
+
+    extern GLGetShaderivProc        getShaderiv;
+    extern GLGetShaderInfoLogProc   getShaderInfoLog;
+    extern GLGetProgramivProc       getProgramiv;
+    extern GLGetProgramInfoLogProc  getProgramInfoLog;
+    extern GLCreateShaderProc       createShader;
+    extern GLShaderSourceProc       shaderSource;
+    extern GLCompileShaderProc      compileShader;
+    extern GLCreateProgramProc      createProgram;
+    extern GLAttachShaderProc       attachShader;
+    extern GLLinkProgramProc        linkProgram;
+    extern GLValidateProgramProc    validateProgram;
+    extern GLDeleteShaderProc       deleteShader;
+    extern GLDeleteProgramProc      deleteProgram;
+    extern GLUseProgramProc         useProgram;
+    extern GLGetUniformLocationProc getUniformLocation;
+    extern GLUniform1fProc          uniform1f;
+    extern GLUniform1iProc          uniform1i;
+    extern GLUniform2fProc          uniform2f;
+    extern GLUniform2iProc          uniform2i;
+    extern GLUniform3fProc          uniform3f;
+    extern GLUniform3iProc          uniform3i;
+    extern GLUniform4fProc          uniform4f;
+    extern GLUniform4iProc          uniform4i;
+    extern GLUniformMatrix4fvProc   uniformMatrix4fv;
+    extern GLGetAttribLocationProc  getAttribLocation;
+
+    extern GLEnableVertexAttribArrayProc  enableVertexAttribArray;
+    extern GLDisableVertexAttribArrayProc disableVertexAttribArray;
+    extern GLVertexAttribPointerProc      vertexAttribPointer;
+
+    extern GLGenRenderbuffersProc genRenderbuffers;
+    extern GLDeleteRenderbuffersProc deleteRenderbuffers;
+    extern GLBindRenderbufferProc    bindRenderbuffer;
+    extern GLFramebufferRenderbufferProc framebufferRenderbuffer;
+    extern GLRenderbufferStorageProc renderbufferStorage;
+
+    #ifndef USE_GLES
+    extern GLCreateShaderObjectARBProc createShaderObjectARB;
+    extern GLCreateProgramObjectARBProc createProgramObjectARB;
+    extern GLShaderSourceARBProc shaderSourceARB;
+    extern GLCompileShaderARBProc compileShaderARB;
+    extern GLValidateProgramARBProc validateProgramARB;
+    extern GLDeleteObjectARBProc deleteObjectARB;
+    extern GLAttachObjectARBProc attachObjectARB;
+    extern GLLinkProgramARBProc linkProgramARB;
+    extern GLUseProgramObjectARBProc useProgramObjectARB;
+    extern GLGetUniformLocationARBProc getUniformLocationARB;
+    extern GLGetAttribLocationARBProc getAttribLocationARB;
+
+    extern GLGetObjectParameterivProc   getObjectParameteriv;
+    extern GLGetInfoLogProc	    getInfoLog;
+    #endif
+
+#ifdef USE_GLES
+
+    static const GLenum 		    FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING;
+    static const GLenum 		    FRAMEBUFFER = GL_FRAMEBUFFER;
+    static const GLenum			    RENDERBUFFER = GL_RENDERBUFFER;
+    static const GLenum 		    COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0;
+    static const GLenum 		    DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT;
+    static const GLenum			    STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT;
+    static const GLenum			    DEPTH24_STENCIL8 = GL_DEPTH24_STENCIL8_OES;
+
+    /* OpenGL|ES does not support different draw/read framebuffers */
+    static const GLenum 		    DRAW_FRAMEBUFFER = GL_FRAMEBUFFER;
+    static const GLenum 		    READ_FRAMEBUFFER = GL_FRAMEBUFFER;
+
+    static const GLenum 		    FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE;
+    static const GLenum 		    FRAMEBUFFER_UNDEFINED = 0;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0;
+    static const GLenum 		    FRAMEBUFFER_UNSUPPORTED = GL_FRAMEBUFFER_UNSUPPORTED;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0;
+    static const GLenum 		    FRAMEBUFFER_INCOMPLETE_DIMENSIONS = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
+
+    static const GLenum 		    ARRAY_BUFFER = GL_ARRAY_BUFFER;
+    static const GLenum 		    STATIC_DRAW = GL_STATIC_DRAW;
+    static const GLenum 		    STREAM_DRAW = GL_STREAM_DRAW;
+    static const GLenum 		    DYNAMIC_DRAW = GL_DYNAMIC_DRAW;
+
+    static const GLenum 		    INFO_LOG_LENGTH = GL_INFO_LOG_LENGTH;
+    static const GLenum 		    COMPILE_STATUS = GL_COMPILE_STATUS;
+    static const GLenum 		    LINK_STATUS = GL_LINK_STATUS;
+    static const GLenum 		    FRAGMENT_SHADER = GL_FRAGMENT_SHADER;
+    static const GLenum 		    VERTEX_SHADER = GL_VERTEX_SHADER;
+
+#else
+
+    static const GLenum 		  FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING_EXT;
+    static const GLenum 		  FRAMEBUFFER = GL_FRAMEBUFFER_EXT;
+    static const GLenum			  RENDERBUFFER = GL_RENDERBUFFER;
+    static const GLenum 		  COLOR_ATTACHMENT0 = GL_COLOR_ATTACHMENT0_EXT;
+    static const GLenum 		  DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT_EXT;
+    static const GLenum			  STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT_EXT;
+    static const GLenum			  DEPTH24_STENCIL8 = GL_DEPTH24_STENCIL8_EXT;
+
+    static const GLenum 		  DRAW_FRAMEBUFFER = GL_DRAW_FRAMEBUFFER_EXT;
+    static const GLenum 		  READ_FRAMEBUFFER = GL_READ_FRAMEBUFFER_EXT;
+    static const GLenum 		  FRAMEBUFFER_COMPLETE = GL_FRAMEBUFFER_COMPLETE_EXT;
+    static const GLenum 		  FRAMEBUFFER_UNDEFINED = GL_FRAMEBUFFER_UNDEFINED;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_READ_BUFFER = GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT;
+    static const GLenum 		  FRAMEBUFFER_UNSUPPORTED = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT;
+    static const GLenum 		  FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0;
+
+    static const GLenum 		  ARRAY_BUFFER = GL_ARRAY_BUFFER_ARB;
+    static const GLenum 		  STATIC_DRAW = GL_STATIC_DRAW_ARB;
+    static const GLenum 		  STREAM_DRAW = GL_STREAM_DRAW_ARB;
+    static const GLenum 		  DYNAMIC_DRAW = GL_DYNAMIC_DRAW_ARB;
+
+    static const GLenum 		  INFO_LOG_LENGTH = GL_OBJECT_INFO_LOG_LENGTH_ARB;
+    static const GLenum 		  COMPILE_STATUS = GL_OBJECT_COMPILE_STATUS_ARB;
+    static const GLenum 		  LINK_STATUS = GL_OBJECT_LINK_STATUS_ARB;
+    static const GLenum 		  FRAGMENT_SHADER = GL_FRAGMENT_SHADER_ARB;
+    static const GLenum 		  VERTEX_SHADER = GL_VERTEX_SHADER_ARB;
+
+#endif
+
     extern bool  textureFromPixmap;
     extern bool  textureRectangle;
     extern bool  textureNonPowerOfTwo;
+    extern bool  textureNonPowerOfTwoMipmap;
     extern bool  textureEnvCombine;
     extern bool  textureEnvCrossbar;
     extern bool  textureBorderClamp;
     extern bool  textureCompression;
     extern GLint maxTextureSize;
-    extern bool  fbo;
-    extern bool  fragmentProgram;
+    extern bool  fboSupported;
+    extern bool  fboStencilSupported;
+    extern bool  fboEnabled;
+    extern bool  vboSupported;
+    extern bool  vboEnabled;
+    extern bool  shaders;
+    extern bool  stencilBuffer;
     extern GLint maxTextureUnits;
 
     extern bool canDoSaturated;
     extern bool canDoSlightlySaturated;
+
+#ifndef USE_GLES
+    void getProgramInfoLogARBWrapper (GLuint object, int maxLen, int *len, char *log);
+    void getShaderInfoLogARBWrapper (GLuint object, int maxLen, int *len, char *log);
+    void getShaderivARBWrapper (GLuint object, GLenum type, int *param);
+    void getProgramivARBWrapper (GLuint object, GLenum type, int *param);
+    GLuint createShaderARBWrapper (GLenum type);
+    GLuint createProgramARBWrapper (GLenum type);
+    void shaderSourceARBWrapper (GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
+    void compileShaderARBWrapper (GLuint shader);
+    void validateProgramARBWrapper (GLuint program);
+    void deleteShaderARBWrapper (GLuint shader);
+    void deleteProgramARBWrapper (GLuint program);
+    void attachShaderARBWrapper (GLuint program, GLuint shader);
+    void linkProgramARBWrapper (GLuint program);
+    void useProgramARBWrapper (GLuint program);
+    int getUniformLocationARBWrapper (GLuint program, const GLchar *name);
+    int getAttribLocationARBWrapper (GLuint program, const GLchar *name);
+#endif
 };
 
 struct GLScreenPaintAttrib {
@@ -220,6 +561,7 @@
 
 #define MAX_DEPTH 32
 
+#ifndef USE_GLES
 struct GLFBConfig {
     GLXFBConfig fbConfig;
     int         yInverted;
@@ -227,6 +569,7 @@
     int         textureFormat;
     int         textureTargets;
 };
+#endif
 
 #define NOTHING_TRANS_FILTER 0
 #define SCREEN_TRANS_FILTER  1
@@ -236,6 +579,7 @@
 extern GLScreenPaintAttrib defaultScreenPaintAttrib;
 
 class GLScreen;
+class GLFramebufferObject;
 
 class GLScreenInterface :
     public WrapableInterface<GLScreen, GLScreenInterface>
@@ -302,11 +646,32 @@
 					     CompOutput *);
 	virtual void glDisableOutputClipping ();
 
+	virtual GLMatrix *projectionMatrix ();
+
+	/**
+	 * Hookable function used by plugins to shade the final composited
+	 * Output.
+	 *
+	 * @param tmpRegion Describes the final composited output region
+	 * @param scratchFbo Describes the final composited FBO that is
+	 * to be rendered.
+	 */
+	virtual void glPaintCompositedOutput (const CompRegion    &region,
+					      GLFramebufferObject *fbo,
+					      unsigned int         mask);
+
+	/**
+	 * Hookable function used by plugins to determine stenciling mask
+	 */
+	virtual void glBufferStencil (const GLMatrix       &matrix,
+				      GLVertexBuffer       &vertexBuffer,
+				      CompOutput           *output);
+
 };
 
 
 class GLScreen :
-    public WrapableHandler<GLScreenInterface, 6>,
+    public WrapableHandler<GLScreenInterface, 8>,
     public PluginClassHandler<GLScreen, CompScreen, COMPIZ_OPENGL_ABI>,
     public CompOption::Class
 {
@@ -332,7 +697,9 @@
 	/**
 	 * Gets the libGL address of a particular openGL functor
 	 */
+	#ifndef USE_GLES
 	GL::FuncPtr getProcAddress (const char *name);
+	#endif
 
 	void updateBackground ();
 
@@ -346,8 +713,6 @@
 	 */
 	void setFilter (int, GLTexture::Filter);
 
-	GLFragment::Storage * fragmentStorage ();
-
 	/**
 	 * Sets a new compiz-wid openGL texture environment mode
 	 */
@@ -356,7 +721,6 @@
 	/**
 	 * Turns lighting on and off
 	 */
-
 	void setLighting (bool lighting);
 
 	/**
@@ -371,7 +735,28 @@
 	GLTexture::BindPixmapHandle registerBindPixmap (GLTexture::BindPixmapProc);
 	void unregisterBindPixmap (GLTexture::BindPixmapHandle);
 
+	#ifndef USE_GLES
 	GLFBConfig * glxPixmapFBConfig (unsigned int depth);
+	#endif
+
+	#ifdef USE_GLES
+	EGLContext getEGLContext ();
+	#endif
+
+	/**
+	 * Returns a GLProgram from the cache or creates one and caches it
+	 */
+	GLProgram *getProgram (std::list<const GLShaderData*>);
+
+	/**
+	 * Returns a GLShaderData from the cache or creates one and caches it
+	 */
+	const GLShaderData *getShaderData (GLShaderParameters &params);
+
+	/**
+	 * Returns the FBO compiz is using for the screen
+	 */
+	GLFramebufferObject *fbo ();
 
 	/**
 	 * Returns a default icon texture
@@ -380,12 +765,6 @@
 
 	void resetRasterPos ();
 
-	/**
-	 * Returns a 4x4 const float array which
-	 * represents the current projection matrix
-	 */
-	const float * projectionMatrix ();
-
 	bool glInitContext (XVisualInfo *);
 
 	WRAPABLE_HND (0, GLScreenInterface, bool, glPaintOutput,
@@ -402,7 +781,16 @@
 		      const GLMatrix &, const CompRegion &, CompOutput *);
 	WRAPABLE_HND (4, GLScreenInterface, void, glDisableOutputClipping);
 
+	WRAPABLE_HND (5, GLScreenInterface, GLMatrix *, projectionMatrix);
+	WRAPABLE_HND (6, GLScreenInterface, void, glPaintCompositedOutput,
+		      const CompRegion &, GLFramebufferObject *, unsigned int);
+
+	WRAPABLE_HND (7, GLScreenInterface, void, glBufferStencil, const GLMatrix &,
+		      GLVertexBuffer &,
+		      CompOutput *);
+
 	friend class GLTexture;
+	friend class GLWindow;
 
     private:
 	PrivateGLScreen *priv;
@@ -454,7 +842,7 @@
 	 * @param mask   Bitmask which describes how this window is drawn
 	 */
 	virtual bool glDraw (const GLMatrix 	&matrix,
-			     GLFragment::Attrib &attrib,
+			     const GLWindowPaintAttrib &attrib,
 			     const CompRegion 	&region,
 			     unsigned int	mask);
 
@@ -479,51 +867,18 @@
 				    const CompRegion 		&clipRegion,
 				    unsigned int		min = MAXSHORT,
 				    unsigned int		max = MAXSHORT);
-	virtual void glDrawTexture (GLTexture *texture, GLFragment::Attrib &,
-				    unsigned int);
-	virtual void glDrawGeometry ();
+	virtual void glDrawTexture (GLTexture *texture, const GLMatrix &,
+	                            const GLWindowPaintAttrib &, unsigned int);
 };
 
 class GLWindow :
-    public WrapableHandler<GLWindowInterface, 5>,
+    public WrapableHandler<GLWindowInterface, 4>,
     public PluginClassHandler<GLWindow, CompWindow, COMPIZ_OPENGL_ABI>
 {
     public:
 
-	/**
-	 * Class which describes the texture geometry and transformation points
-	 * of a window
-	 */
-	class Geometry {
-	    public:
-		Geometry ();
-		~Geometry ();
-
-		void reset ();
-
-		/**
-		 * Set the number of vertices in the texture geometry
-		 */
-		bool moreVertices (int newSize);
-
-		/**
-		 * Set the number of indices in the texture geometry
-		 */
-		bool moreIndices (int newSize);
-
-	    public:
-		GLfloat  *vertices;
-		int      vertexSize;
-		int      vertexStride;
-		GLushort *indices;
-		int      indexSize;
-		int      vCount;
-		int      texUnits;
-		int      texCoordSize;
-		int      indexCount;
-	};
-
 	static GLWindowPaintAttrib defaultPaintAttrib;
+
     public:
 
 	GLWindow (CompWindow *w);
@@ -566,9 +921,20 @@
 	void updatePaintAttribs ();
 
 	/**
-	 * Returns the window texture geometry
-	 */
-	Geometry & geometry ();
+	 * Returns the window vertex buffer object
+	 */
+	GLVertexBuffer * vertexBuffer ();
+
+	/**
+	 * Add a vertex and/or fragment shader function to the pipeline.
+	 *
+	 * @param name Name of the plugin adding the functions
+	 * @param vertex_shader Function to add to the vertex shader
+	 * @param fragment_shader Function to add to the fragment shader
+	 */
+	void addShaders (std::string name,
+	                 std::string vertex_shader,
+	                 std::string fragment_shader);
 
 	GLTexture *getIcon (int width, int height);
 
@@ -576,14 +942,15 @@
 		      const GLWindowPaintAttrib &, const GLMatrix &,
 		      const CompRegion &, unsigned int);
 	WRAPABLE_HND (1, GLWindowInterface, bool, glDraw, const GLMatrix &,
-		      GLFragment::Attrib &, const CompRegion &, unsigned int);
+		      const GLWindowPaintAttrib &, const CompRegion &,
+	              unsigned int);
 	WRAPABLE_HND (2, GLWindowInterface, void, glAddGeometry,
 		      const GLTexture::MatrixList &, const CompRegion &,
 		      const CompRegion &,
 		      unsigned int = MAXSHORT, unsigned int = MAXSHORT);
 	WRAPABLE_HND (3, GLWindowInterface, void, glDrawTexture,
-		      GLTexture *texture, GLFragment::Attrib &, unsigned int);
-	WRAPABLE_HND (4, GLWindowInterface, void, glDrawGeometry);
+		      GLTexture *texture, const GLMatrix &,
+	              const GLWindowPaintAttrib &, unsigned int);
 
 	friend class GLScreen;
 	friend class PrivateGLScreen;
@@ -593,3 +960,4 @@
 };
 
 #endif
+

=== added file 'plugins/opengl/include/opengl/program.h'
--- plugins/opengl/include/opengl/program.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/program.h	2012-08-22 06:16:22 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2011 Linaro Ltd.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Linaro Ltd. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Linaro Ltd. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * LINARO LTD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL LINARO LTD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Authors: Travis Watkins <[e-mail]>
+ */
+
+#ifndef _COMPIZ_GLPROGRAM_H
+#define _COMPIZ_GLPROGRAM_H
+
+#ifdef USE_GLES
+#include <GLES2/gl2.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include <core/core.h>
+#include <opengl/matrix.h>
+
+class PrivateProgram;
+
+class GLProgram
+{
+    public:
+	GLProgram (CompString &vertexShader, CompString &fragmentShader);
+	~GLProgram ();
+