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

[Daniel van Vugt (vanvugt)]

Known issues with this branch:
https://bugs.launchpad.net/compiz-core/+milestone/gles-0.9.8

[Daniel van Vugt (vanvugt)]

WARNING:
Launchpad is _still_ not showing an accurate diff here. For example the new file 'plugins/water/src/shaders.h' is not shown below. Nor are any of the other changes to plugins/water.

Do not rely on the accuracy of the diff reported here!

[Tim Penhey (thumper)]

The diff is truncated for viewing on this page at 5000 lines.

I grabbed the branches locally, did a merge and a diff and got the following:

$ bzr diff | wc -l
11153

$ bzr diff | diffstat
 CMakeLists.txt | 3
 cmake/CMakeLists.txt | 2
 cmake/CompizCommon.cmake | 12
 cmake/CompizPlugin.cmake | 31
 cmake/FindOpenGLES2.cmake | 51
 cmake/base.cmake | 4
 cmake/plugin_extensions/CompizOpenGLFixups.cmake | 22
 include/core/wrapsystem.h | 8
 plugins/annotate/src/annotate.cpp | 224 ++--
 plugins/blur/CMakeLists.txt | 24
 plugins/clone/src/clone.cpp | 5
 plugins/compiztoolbox/src/compiztoolbox.cpp | 42
 plugins/copytex/src/copytex.cpp | 9
 plugins/cube/CMakeLists.txt | 2
 plugins/cube/include/cube/cube.h | 15
 plugins/cube/src/cube.cpp | 165 +--
 plugins/decor/src/decor.cpp | 56 -
 plugins/decor/src/decor.h | 6
 plugins/imgsvg/src/imgsvg.cpp | 21
 plugins/imgsvg/src/imgsvg.h | 3
 plugins/obs/src/obs.cpp | 17
 plugins/obs/src/obs.h | 2
 plugins/opengl/CMakeLists.txt | 13
 plugins/opengl/compiz-opengl.pc.in | 4
 plugins/opengl/include/opengl/fragment.h | 125 --
 plugins/opengl/include/opengl/framebufferobject.h | 107 ++
 plugins/opengl/include/opengl/matrix.h | 2
 plugins/opengl/include/opengl/opengl.h | 336 +++++-
 plugins/opengl/include/opengl/program.h | 75 +
 plugins/opengl/include/opengl/programcache.h | 51
 plugins/opengl/include/opengl/shadercache.h | 100 +
 plugins/opengl/include/opengl/texture.h | 5
 plugins/opengl/include/opengl/vector.h | 6
 plugins/opengl/include/opengl/vertexbuffer.h | 123 ++
 plugins/opengl/src/fragment.cpp | 1146 ----------------------
 plugins/opengl/src/framebufferobject.cpp | 191 +++
 plugins/opengl/src/matrix.cpp | 54 +
 plugins/opengl/src/paint.cpp | 829 +++++++--------
 plugins/opengl/src/privatefragment.h | 54 -
 plugins/opengl/src/privates.h | 47
 plugins/opengl/src/privatetexture.h | 32
 plugins/opengl/src/privatevertexbuffer.h | 141 ++
 plugins/opengl/src/program.cpp | 262 +++++
 plugins/opengl/src/programcache.cpp | 175 +++
 plugins/opengl/src/screen.cpp | 617 ++++++++++-
 plugins/opengl/src/shadercache.cpp | 246 ++++
 plugins/opengl/src/texture.cpp | 147 ++
 plugins/opengl/src/vector.cpp | 8
 plugins/opengl/src/vertexbuffer.cpp | 567 ++++++++++
 plugins/opengl/sr...

[Daniel van Vugt (vanvugt)]

If you click on "Download diff" then you will get the complete (accurate) diff.

[lp:~compiz-linaro-team/compiz/gles2]

3204. By Daniel van Vugt on 2012-05-18

Disable plugins that don't build any more.

3205. By Daniel van Vugt on 2012-05-18

Disable ugly SGX driver workaround if not building for GLES

[Daniel van Vugt (vanvugt)]

Issues with this branch are now being tracked here:
https://bugs.launchpad.net/compiz/+bugs?field.tag=gles

I consider the High and Critical bugs blockers, because they affect the default Unity/Ubuntu desktop.

review: Needs Fixing

[lp:~compiz-linaro-team/compiz/gles2]

3206. By Sam Spilsbury on 2012-05-22

Merge lp:compiz/0.9.8

3207. By Travis Watkins on 2012-05-22

Port the animation plugin to use GLVertexBuffer and new OpenGL Plugin API

3208. By Travis Watkins on 2012-05-22

Port the expo plugin to use GLVertexBuffer and the new OpenGL plugin API

3209. By Travis Watkins on 2012-05-22

Port the ezoom plugin to use GLVertexBuffer and new OpenGL plugin API

3210. By Travis Watkins on 2012-05-22

Port kdecompat plugin to use GLVertexBuffer and new OpenGL API

3211. By Travis Watkins on 2012-05-22

Port neg plugin to use GLVertexBuffer and new OpenGL plugin API

3212. By Travis Watkins on 2012-05-22

Port resizeinfo plugin to use GLVertexBuffer and new OpenGL plugin API

3213. By Travis Watkins on 2012-05-22

Port text plugin to use GLVertexBuffer and new OpenGL plugin API

3214. By Travis Watkins on 2012-05-22

Port scaleaddon plugin to use GLVertexBuffer and new OpenGL plugin API

3215. By Travis Watkins on 2012-05-22

Port scalefilter plugin to use GLVertexBuffer and new OpenGL plugin API

3216. By Sam Spilsbury on 2012-05-22

Call API with the right arguments

3217. By Travis Watkins on 2012-05-22

Port ring plugin to use GLVertexBuffer and new OpenGL plugin API

3218. By Travis Watkins on 2012-05-22

Port shift plugin to use GLVertexBuffer and new OpenGL plugin API

3219. By Travis Watkins on 2012-05-22

Port wall plugin to use GLVertexBuffer and new OpenGL plugin API

3220. By Sam Spilsbury on 2012-05-22

Merge lp:compiz/0.9.8

3221. By Travis Watkins on 2012-05-22

Port workarounds plugin to use GLVertexBuffer and new OpenGL plugin API

3222. By Travis Watkins on 2012-05-22

Port staticswitcher plugin to use GLVertexBuffer and new OpenGL plugin API

3223. By Travis Watkins on 2012-05-22

Port grid plugin to use GLVertexBuffer and new OpenGL plugin API

3224. By Sam Spilsbury on 2012-05-22

Fix BUILD_GLES builds

3225. By Sam Spilsbury on 2012-05-26

Merge lp:compiz

3226. By Sam Spilsbury on 2012-05-26

Reset the viewport when painting composited output

3227. By Sam Spilsbury on 2012-05-26

Merged from lp:~compiz-linaro-team/compiz/gles2

3228. By Sam Spilsbury on 2012-05-26

Less noisy logging when fbo binds fail

3229. By Sam Spilsbury on 2012-05-28

Merge lp:compiz

3230. By Sam Spilsbury on 2012-05-28

Don't paint nonsliding windows multiple times.

There's a risk that a nonsliding window could be painted
on top of other partially sliding windows which would
manifest itself in clipping errors. In addition, its a waste
of time to do so

3231. By Sam Spilsbury on 2012-05-28

Merge lp:~compiz-linaro-team/compiz/gles2 and fix typo

3232. By Daniel van Vugt on 2012-05-29

Fixed: switcher did not fade out properly any more (LP: #1005466)

3233. By Sam Spilsbury on 2012-06-02

Don't include glu.h if building with GLES

3234. By Sam Spilsbury on 2012-06-02

Added some functions to transpose a matrix in place

3235. By Sam Spilsbury on 2012-06-02

Don't paint desktop windows multiple times if not sliding

[Sam Spilsbury (smspillaz)]

Some things to change after using the API for a bit:

1. GLVertexBuffer::streamingBuffer () is used almost everywhere as a singleton, this makes it difficult to mock out for testing. In addition, fraught with problems to do with shared usage
2. GLVertexBuffer::begin () and GLVertexBuffer::end () need to be renamed to something else as they can confuse the standard library
3. GLVertexBuffer::setAutoProgram needs to go away - the parameter needs to be a part of the constructor, as normal usage of GLVertexBuffer will crash if you don't call setAutoProgram.
4. The usage of va_args in Uniform is not nice, but necessary as it stands - could be replaced with variadic templates
5. GLVertexBuffer::setUniform (GLfloat *) will work but silently fail - it makes a lot of sense to be able to pass an array to setUniform for the purposes of setting a vec4 in a shader. Perhaps an overload specifying the size would make sense?

[lp:~compiz-linaro-team/compiz/gles2]

3236. By Sam Spilsbury on 2012-06-02

Merge lp:compiz

3237. By Sam Spilsbury on 2012-06-08

Merge lp:compiz

3238. By Sam Spilsbury on 2012-06-08

Fix build problems with GCC 4.7

3239. By Sam Spilsbury on 2012-06-09

Hi nive test

3240. By Sam Spilsbury on 2012-06-15

Desktop GL requires the use of GL_FRAMEBUFFER_EXT and friends for glFramebuffer*EXT
and not GL_FRAMEBUFFER

(LP: #1013487)

3241. By Sam Spilsbury on 2012-06-15

Fix GLES build

3242. By Sam Spilsbury on 2012-06-15

Remove a debugging statement that shouldn't have been there

[Sam Spilsbury (smspillaz)]

Unfortunately we're being hit by a ton of bugs in the nvidia driver.

At the moment it just crashes when using Vertex Buffer Objects. The only documentation I've found on the web so far is "just don't use them", which is obviously not satisfactory, so we'll need to find a workaround for that. See bug 1006211.

Also when using the non-vbo mode, rendering only happens in the top right hand corner. See bug 1013514

[Sam Spilsbury (smspillaz)]

(Recently fixed: bug 1013487 which caused framebuffers not to work. An important point to note here is that the use of the GLenum constants and identifiers must end with the same suffixes used for the functions if they are an extension. This may be the cause of bug 1006211)

[lp:~compiz-linaro-team/compiz/gles2]

3243. By Sam Spilsbury on 2012-06-17

  Use the OpenGL API correctly.

  Since we lookup the ARB functions for both GL_ARB_vertex_buffer_object and
  GL_ARB_fragment_shader/GL_ARB_vertex_shader, we must only depend on the
  entrypoints and tokens that are provided in those functions, and not
  mix the tokens and entrypoints between those functions and core OpenGL 2
  functionality.

3244. By Sam Spilsbury on 2012-06-17

  Fix crash in glDrawArrays

  The NVIDIA driver looks to see if the legacy GL_VERTEX_ARRAY,
  GL_TEXTURE_COORDINATES_ARRAY and other such client states are enabled
  first before checking if a vertex buffer is bound and will prefer the
  client buffers over the the vertex buffer object.

  There isn't anywhere in the OpenGL specification that says that
  the driver can't do that, however, it can inadvertently affect performance.

  In addition, if no glVertexPointer was specified and the GL_VERTEX_ARRAY
  client state is left on then it will attempt to read from NULL blindly.

  The solution is to remove the legacy code that turned GL_VERTEX_ARRAY
  and GL_TEXTURE_COORDINATES_ARRAY on by default

  (LP :#1006211)

[Sam Spilsbury (smspillaz)]

The relevant nvidia bug 1006211 is now fixed. With lp:~smspillaz/compiz/compiz.gles2.always-swapbuffers everything should work fine on nvidia. Without it redrawing will appear to freeze until the next frame.

[lp:~compiz-linaro-team/compiz/gles2]

3245. By Sam Spilsbury on 2012-06-22

Merge lp:compiz

3246. By Sam Spilsbury on 2012-06-24

Merge lp:compiz

3247. By Sam Spilsbury on 2012-06-25

decor: Fix build

3248. By Sam Spilsbury on 2012-06-29

Merge lp:compiz

3249. By Sam Spilsbury on 2012-07-04

Merge lp:compiz

3250. By Daniel van Vugt on 2012-07-04

Disable stackswitch plugin. It's not compatible with GLES yet.

3251. By Daniel van Vugt on 2012-07-04

Fix XDamageReport regression (was using XDamageReportRawRectangles)

3252. By Sam Spilsbury on 2012-07-04

Implement initial support for stencil buffering.
(LP: #1005468) (LP: #1005464)

glClipPlane (vertex based user clipping) isn't supported in GLES
or in combination with GL2's vertex shaders. As such, we need
to replace it with a more modern alternative.

A wrapable function was added glBufferStencil which provides
plugins with a GLVertexBuffer, and readonly GLMatrix and
CompOutput. This allows plugins to draw in areas where stenciling
will pass using the passed GLVertexBuffer.

3253. By Sam Spilsbury on 2012-07-06

Merge lp:compiz

3254. By Daniel van Vugt on 2012-07-09

Choose a default minimize/restore animation that actually works with the
gles2 branch... Change Magic Lamp to Glide 2.

Magic Lamp still doesn't work (bug 1003255).

3255. By on 2012-07-09

Always use *SwapBuffers instead of using glCopyPixels. Introduces a dependency
on either having EGL_NV_post_sub_buffer OR GLX_MESA_copy_sub_buffer OR
OpenGL 3.0 OR GL_EXT_framebuffer_object.

3256. By Daniel van Vugt on 2012-07-09

Don't redraw shadows outside of the region specified by glDraw().
(LP: #1022463)

3257. By Daniel van Vugt on 2012-07-11

Remove damageScreen hack from the animation plugin. It's not required now
that we have working glXSwapBuffers always on. This should make animations
smoother, especially when using unityshell.

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3257
http://jenkins.qa.ubuntu.com/job/compiz-ci/3/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=amd64/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=i386/3/console

review: Needs Fixing (continuous-integration)

[Martin Mrazik (mrazik)]

The jenkins failure is because of connectivity issues to us.archive.ubuntu.com. Sorry for false negative.

[lp:~compiz-linaro-team/compiz/gles2]

3258. By Sam Spilsbury on 2012-07-11

Merge lp:compiz

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:3258
http://jenkins.qa.ubuntu.com/job/compiz-ci/6/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=amd64/6/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=i386/6/console

review: Approve (continuous-integration)

[lp:~compiz-linaro-team/compiz/gles2]

3259. By Sam Spilsbury on 2012-07-12

Don't build trip plugin

3260. By Daniel van Vugt on 2012-07-12

Merge lp:compiz

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3259
http://jenkins.qa.ubuntu.com/job/compiz-ci/11/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=amd64/11/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=i386/11/console

review: Needs Fixing (continuous-integration)

[Martin Mrazik (mrazik)]

The previous fail is again a network hiccup :-/

[jenkins (martin-mrazik+qa)]

FAILED: Continuous integration, rev:3260
http://jenkins.qa.ubuntu.com/job/compiz-ci/15/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=amd64/15/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=i386/15/console

review: Needs Fixing (continuous-integration)

[lp:~compiz-linaro-team/compiz/gles2]

3261. By Daniel van Vugt on 2012-07-13

Re-introduce working glCopyPixels support, allowing regional redraws to
work again (but disabled by default) on LLVMpipe and NVIDIA.
(LP: #1013514)

3262. By Daniel van Vugt on 2012-07-13

Fix crash on startup due to incorrect detection of GL_EXT_framebuffer_object
functions when GL_EXT_packed_depth_stencil is not present [fglrx].
(LP: #1024273)

3263. By Daniel van Vugt on 2012-07-13

GL_EXT_framebuffer_object is not a requirement, just nice to have.

Don't crash if it's missing!

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:3261
http://jenkins.qa.ubuntu.com/job/compiz-ci/16/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=amd64/16/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./distribution=quantal,flavor=i386/16/console

review: Approve (continuous-integration)

[lp:~compiz-linaro-team/compiz/gles2]

3264. By Sam Spilsbury on 2012-07-17

Added tests for sub-buffer-copy logic.

3265. By Daniel van Vugt on 2012-07-17

Clean up misleading use of "blit" and "copy". Also use simpler, clearer
method names in the DoubleBuffer classes.

3266. By Daniel van Vugt on 2012-07-17

Fixed up more misleading use of the word "blit".

3267. By Daniel van Vugt on 2012-07-19

Merge latest lp:compiz

3268. By Daniel van Vugt on 2012-07-19

Fix MASSIVE CPU usage regression, caused by glGetBooleanv.

On GLES, we have to use glGetBooleanv because glPushAttrib/PopAtrib are
not available. However each call to glGetBooleanv involves a round trip and
heavy CPU usage, so you definitely don't want to call it on GLX.

3269. By Daniel van Vugt on 2012-07-19

Another small performance improvement: Avoid using glGetIntegerv because
it requires a round trip to the X server and significant CPU usage.

3270. By Daniel van Vugt on 2012-07-19

Avoid more pointless (and expensive) FBO rebinds.

3271. By Daniel van Vugt on 2012-07-20

If water is not supported, don't crash. Give a nice error message.
(LP: #1026899)

3272. By Daniel van Vugt on 2012-07-20

Fixed broken stencil buffer detection, which was giving up on stenciling
even when it is supported. This caused graphical bugs:
(LP: #1024299) (LP: #1024297)

3273. By Daniel van Vugt on 2012-07-20

Always log the rendering features being used. It's critical information to
know at least while debugging gles2.

3274. By Daniel van Vugt on 2012-07-20

Quick fix for broken blending with the fglrx driver (LP: #1002947)
... or probably any driver where !GL::shaders

But a nicer fix still needs to be found I think, as mentioned in
GLVertexBuffer::supported ().

3275. By Daniel van Vugt on 2012-07-20

Add a useful comment about enableLegacyOBSAndRender

3276. By Daniel van Vugt on 2012-07-20

Add a comment warning about the fglrx "compiz" binary detection problem.
THAT is the reason why I couldn't get shader support on fglrx -- because the
driver has a (wrong) hack built in to disable it if your program is named
"compiz". To workaround this terrible mistake in the fglrx driver, just
be sure your compiz binary is not named "compiz".

3277. By Alexandros Frantzis on 2012-07-23

mag: Port "simple" mode to modern GL/GLES2 and enable the plugin.

3278. By Daniel van Vugt on 2012-07-23

FBO and VBO support are now options, which you can disable for performance
and compatibility reasons. Default: enabled.

3279. By Daniel van Vugt on 2012-07-23

Add support for buffer swapping (on by default) even if FBOs are not
available.

3280. By Daniel van Vugt on 2012-07-23

Optimize GLXDoubleBuffer::fallbackBlit, by removing the slow synchronous
glGet* functions.

3281. By Daniel van Vugt on 2012-07-23

Quick workaround for scale overdraw bug LP: #1026986

[Sam Spilsbury (smspillaz)]

1727
static void

1728
copyFrontToBack()

1729
{

1730
    int w = screen->width ();

1731
    int h = screen->height ();

1732

1733
    glMatrixMode (GL_PROJECTION);

1734
    glPushMatrix ();

1735
    glLoadIdentity ();

1736
    glOrtho (0, w, 0, h, -1.0, 1.0);

1737
    glMatrixMode (GL_MODELVIEW);

1738
    glPushMatrix ();

1739
    glLoadIdentity ();

1740

1741
    glReadBuffer (GL_FRONT);

1742
    glRasterPos2i (0, 0);

1743
    glCopyPixels (0, 0, w, h, GL_COLOR);

1744
    glReadBuffer (GL_BACK);

1745

1746
    glPopMatrix ();

1747
    glMatrixMode (GL_PROJECTION);

1748
    glPopMatrix ();

1749
    glMatrixMode (GL_MODELVIEW);

1750
}

Please put that inside a namespace {}

or better, encapsulate the fbo bind/unbind and copyBackToFront logic as part of GLDoubleBuffer so that we can avoid the #ifdef .

[Daniel van Vugt (vanvugt)]

Hmm, be careful what you paste :)

I agree, that would be nicer in the GLXDoubleBuffer class. Just haven't done so yet because it requires a little more interface change.

[lp:~compiz-linaro-team/compiz/gles2]

3282. By Daniel van Vugt on 2012-07-24

Remove #ifdefs by merging front-to-back copying into *DoubleBuffer.

3283. By Daniel van Vugt on 2012-07-24

Tidy up class names. The "GL" prefix is not required for the abstract base
class which is not GL-specific, but already in namespace "opengl". And the
suffix "Interface" is unnecessary.

3284. By Daniel van Vugt on 2012-07-24

No need for multiple inheritance, so remove it.

3285. By Daniel van Vugt on 2012-07-24

Clean up DoubleBuffer classes:
  - Don't pass around so many bool parameters to render() and swap().
  - Eliminate boost::function usage.

3286. By Daniel van Vugt on 2012-07-24

Failure to bind the framebuffer object is a transient recoverable error. So
don't give up permanently if it happens once. (LP: #1013487)

Usually this happens if you're starting compiz from a different VT to the
one that X is running on.

3287. By Daniel van Vugt on 2012-07-24

Minor cleanups in PrivateGLScreen::paintOutputs

3288. By Daniel van Vugt on 2012-07-25

Merge latest lp:compiz

3289. By Daniel van Vugt on 2012-07-25

Avoid glPushAttrib/glPopAttrib which is also slow on some drivers like nvidia.
(LP: #1028790)

3290. By Daniel van Vugt on 2012-07-25

Remove more glPushAttrib/glPopAttrib which are extremely slow on some drivers,
like nvidia. (LP: #1028801)

3291. By Daniel van Vugt on 2012-07-25

Remove dead code, which is also two round-trips (glGerError).

3292. By Daniel van Vugt on 2012-07-25

Eliminate nested vector std::vector<std::vector<GLfloat>> which was being
used in a way that prevented efficient memory reuse, resulting in high CPU
(new, delete, memmove). (LP: #1028768)

3293. By Daniel van Vugt on 2012-07-25

Remove pointless if()

3294. By Daniel van Vugt on 2012-07-26

Merge latest lp:compiz and fix conflicts

3295. By Daniel van Vugt on 2012-07-26

Simplify and optimize glClear usage. Go back to the old logic from trunk.

3296. By Daniel van Vugt on 2012-07-26

Fixed: resizeinfo would become invisible after fading in (LP: #1029366)

3297. By Daniel van Vugt on 2012-07-26

Fix more opacity/blending bugs where 100% opacity would be rendered as
0% opacity (invisible).

3298. By Daniel van Vugt on 2012-07-27

Merge latest lp:compiz

3299. By Daniel van Vugt on 2012-07-27

Fix regression; glDrawTexture was being called MUCH more than it does with
trunk. (LP: #1029806)

This was because Linaro removed GLWindow::Geometry, and the decision to call
glDrawTexture used to be conditional on GLWindow::Geometry::vCount. So they
just removed the if's and made it unconditional, hence slower.

Now I've reintroduced GLWindow::Geometry::vCount in the form of
GLVertexBuffer::countVertices, and glDrawTexture is only called conditionally
again.

This will also make it possible/easy to reintroduce some deformation features
that are presently commented out (by Linaro). We will just have to convert:
    GLWindow::Geometry::vCount
    GLWindow::Geometry::vertices
to:
    GLVertexBuffer::countVertices()
    GLVertexBuffer::getVertices()

3300. By Daniel van Vugt on 2012-07-27

Work in progress: Expo deformation == Curve now compiles, but crashes if
activated.

This is because glAddGeometry lacks in-situ vertex list update support,
which it used to have.

3301. By Daniel van Vugt on 2012-07-30

Merge latest lp:compiz

3302. By Daniel van Vugt on 2012-07-30

Scripted removal of whitespace-only changes. This shrinks the diff to trunk
by about 500 lines.

3303. By Daniel van Vugt on 2012-07-30

Remove evil oversized macros

3304. By Daniel van Vugt on 2012-07-30

Don't explicitly inline functions, especially when they expand to such a
large amount of code. The compiler will do a better job of deciding how to
optimize.

3305. By Daniel van Vugt on 2012-07-30

Avoid (apparently) non-standard std::vector<>::data()

3306. By Daniel van Vugt on 2012-07-30

Fixed expo Deformation==Curve crashes. Still doesn't render all workspaces.
Seems to be missing the currently selected and previous ones.

3307. By Daniel van Vugt on 2012-07-30

Revert previous commit. It only seemed to work because running through
1/3 of the vertices avoided the overrun crash. Only iterating through 1/3
was a mistake.

3308. By Daniel van Vugt on 2012-07-30

Fixed expo Deformation==Curve crash properly. I am an idiot.

3309. By Daniel van Vugt on 2012-07-30

Remove dead code "n", which used to be used for counting quads.

3310. By Daniel van Vugt on 2012-07-31

Merge latest lp:compiz

3311. By Daniel van Vugt on 2012-07-31

const'ify GLVertexBuffer where appropriate.

3312. By Daniel van Vugt on 2012-07-31

Allow partial fallback to legacy VBO rendering when !GL::shaders, if that's
what you need (like with fglrx). Fixed enableLegacyOBSAndRender so it works
with GLVertexBuffer, however there is one odd case that still doesn't work:
brightness < BRIGHT for paintBackground. You will see that in expo mode as
the desktop background does not fade its brightness smoothly. A simple
workaround is to set expo saturation < 1.0 so it uses the more complex (and
visually correct) glTex* logic in enableLegacyOBSAndRender.

3313. By Daniel van Vugt on 2012-07-31

Workaround the desktop background brightness problem with expo, so I don't
have to log a bug for it. This code path is only used on fglrx normally
(where !GL::shaders).

3314. By Daniel van Vugt on 2012-07-31

Fix completely broken texturing (of the mouse cursor) in ezoom. Obviously
it was never tested at all when ported to GLES. (LP: #1031252)

3315. By Daniel van Vugt on 2012-07-31

More magic scripting to remove whitespace changes that are bloating the diff
to trunk.

3316. By Sam Spilsbury on 2012-08-01

Fix build failure with BUILD_GLES

3317. By Daniel van Vugt on 2012-08-01

Fixed: ezoom cursor texture was not honouring the opengl texture filter
setting.

3318. By Daniel van Vugt on 2012-08-01

water: Fix invalid range for the light_vec_z option.

3319. By Daniel van Vugt on 2012-08-01

Revert yesterday's legacy rendering cleanups. They're causing blending
problems which are worse (LP: #1031620)

3320. By Daniel van Vugt on 2012-08-01

Fixed order of glEnableOutputClipping/sTransform.toScreenSpace which got
mixed up in the GLES port. But no one noticed so long as
GL::stencilBuffer==true. (LP: #1031661)

3321. By Daniel van Vugt on 2012-08-01

Fix indentation

3322. By Daniel van Vugt on 2012-08-02

Remove dead code introduced in wall plugin

3323. By Daniel van Vugt on 2012-08-02

Simplified and optimized stenciling.

We don't need or use the depth buffer, so remove dependency on extension
GL_DEPTH24_STENCIL8_EXT/OES and just use standard OpenGL stenciling.

3324. By Daniel van Vugt on 2012-08-02

Add matrix debug code. Will still need it later.

3325. By Daniel van Vugt on 2012-08-02

Avoid potential NULL pointer dereferences.

3326. By Daniel van Vugt on 2012-08-02

Remove dead code: GLMatrix::transpose
It also looks like it never worked; swapping each opposing pair twice.

3327. By Daniel van Vugt on 2012-08-03

Merged latest lp:compiz and fix a conflict.

3328. By Daniel van Vugt on 2012-08-03

Use scissoring for clipping when possible, which avoids performance problems
of stencilling (LP: #1027863)

3329. By Daniel van Vugt on 2012-08-03

Clean up GLScreen::glPaintTransformedOutput

3330. By Daniel van Vugt on 2012-08-03

Fix indentation.

3331. By Daniel van Vugt on 2012-08-03

Fixed bottom face missing from the cube. (LP: #1032545)

It seems vertexOffset was declared but functionally never implemented till
now.

3332. By Daniel van Vugt on 2012-08-06

Merge latest lp:compiz and fix conflicts.

3333. By Daniel van Vugt on 2012-08-06

Add scaled output support to the glScissor'ing. This fixes clipping problems
with wobbly windows in expo mode. (LP: #1032518)

3334. By Daniel van Vugt on 2012-08-06

Add support for negative scaling transforms, as used in expo reflection mode
(LP: #1033392)

3335. By Daniel van Vugt on 2012-08-06

Simplified scaled output clipping/scissoring logic.

[Sam Spilsbury (smspillaz)]

Apologies for the large paste, though this bit of code feels a bit weird:

// transformIsSimple tells you if it's simple enough to use scissoring
static bool
transformIsSimple (const GLMatrix &transform)
{
    const float *t = transform.getMatrix ();
    return // t[0] can be anything (x scale)
           t[1] == 0.0f &&
           t[2] == 0.0f &&
           t[3] == 0.0f &&
           t[4] == 0.0f &&
           // t[5] can be anything (y scale)
           t[6] == 0.0f &&
           t[7] == 0.0f &&
           t[8] == 0.0f &&
           t[9] == 0.0f &&
           // t[10] can be anything (z scale)
           t[11] == 0.0f &&
           // t[12]..t[14] can be anything (translation)
           t[15] == 1.0f;
}

void
GLScreen::glEnableOutputClipping (const GLMatrix &transform,
      const CompRegion &region,
      CompOutput *output)
{
    WRAPABLE_HND_FUNCTN (glEnableOutputClipping, transform, region, output)

    // Bottom-left corner of the output:
    const GLint x = output->x1 ();
    const GLint y = screen->height () - output->y2 ();
    const GLsizei w = output->width ();
    const GLsizei h = output->height ();

    // Transformed (only scale and translation is supported!)
    const float *t = transform.getMatrix ();
    const GLfloat scalex = t[0], scaley = t[5], transx = t[12], transy = t[13];
    const GLfloat centrex = x + w / 2.0f;
    const GLfloat centrey = y + h / 2.0f;
    const GLfloat scaledw = w * scalex;
    const GLfloat scaledh = h * scaley;
    const GLint tx = centrex - (scaledw / 2.0f) + transx * w;
    const GLint ty = centrey - (scaledh / 2.0f) + transy * h;

    glScissor (tx, ty, scaledw, scaledh);
    glEnable (GL_SCISSOR_TEST);
}

void
GLScreen::glDisableOutputClipping ()
{
    WRAPABLE_HND_FUNCTN (glDisableOutputClipping)

    glDisable (GL_SCISSOR_TEST);
}

The historical purpose of glEnableOutputClipping and glDisableOutputClipping was for plugins to specify their own clip planes. At the moment, we still have extension points for those functions, although the usage of these functions have effectively been hijacked for scissoring to the output region (scaled and transformed by an orthogonal transformation matrix).

It feels a bit weird having these extension points remain if they don't do anything. In addition, the plugins are still going to try and enable their own clip planes (see cube) along with scissoring, and this codepath will be taken even if we are using the shader codepath without support for such clip planes.

I think there are two roads we can take:

 1) Remove glEnableOutputClipping/glDisableOutputClipping entirely - go with either scissoring if the transfomation matrix is orthogonal, or stencil buffers failing that.
 2) Re-introduce glEnableOutputClipping/glDisableOutputClipping properly, make them the last resort case in case the transformation matrix is not orthogonal and stencil buffering is not available. This codepath should only be taken if we aren't using vertex shaders, or the vertex shader should be disabled entirely if we are.

I think there's another consideration that needs to be made here:

At the moment, we ar...

[Daniel van Vugt (vanvugt)]

I agree there's too much wrapping and inappropriate behaviour going on now. That's something I was thinking needed cleaning up too.

Although we should take a step back and re-evaluate what plugins actually need. Then simplify the API down to just minimum requirements.

[lp:~compiz-linaro-team/compiz/gles2]

3336. By Daniel van Vugt on 2012-08-06

Go back to using GL_*_packed_depth_stencil. Seems to be necessary to keep
NVIDIA happy. I also read some GLES hardware like SGX chips require it.
(LP: #1033404)

But this time make it clear that stencilling in an FBO and regular
stencilling are different things.

3337. By Daniel van Vugt on 2012-08-07

Merge latest lp:compiz

3338. By Daniel van Vugt on 2012-08-07

Revert non-functional/incomplete code changes. It is more useful to have the
old code commented out, than to replace it with something new that does not
work at all yet.

This will make full porting of the animation plugin easier in future, and
also shrinks the diff to trunk.

3339. By Daniel van Vugt on 2012-08-07

animation: Clean up the project() function and its caller.

3340. By Daniel van Vugt on 2012-08-08

Merge latest lp:compiz

3341. By Daniel van Vugt on 2012-08-08

Merge latest lp:compiz

3342. By Daniel van Vugt on 2012-08-08

GLVertexBuffer::end() now returns bool == !vertexData.empty()

So you can use the result of end() to know whether there is anything to render.

3343. By Daniel van Vugt on 2012-08-08

Simplify two different versions of GLVertexBuffer::begin() into one.

3344. By Daniel van Vugt on 2012-08-08

Fix broken blending in staticswitcher (LP: #1034290)

3345. By Daniel van Vugt on 2012-08-08

Fix missing reflection (blending) in the shift switcher (LP: #1034289)

3346. By Daniel van Vugt on 2012-08-09

Remove out-of-date TODO and FIXME.

3347. By Daniel van Vugt on 2012-08-09

water: Fix indentation, comments, whitespace changes.

3348. By Daniel van Vugt on 2012-08-09

vertexbuffer: Resolve a FIXME. Check input parameter, and if it's not valid
then correct it. An invalid parameter would only impact performance in theory,
not functionality.

3349. By Daniel van Vugt on 2012-08-09

double-buffer.cpp: Resolve a FIXME and add missing license/copyright.

3350. By Daniel van Vugt on 2012-08-09

Add a helpful hint to a FIXME.

3351. By Daniel van Vugt on 2012-08-09

workarounds: Restore code that was deleted inexplicably in gles2. Looks like
it really should still be there according to docs.

3352. By Daniel van Vugt on 2012-08-09

expo: Resolve an "XXX" - finish porting curve mode to GLVertexBuffer.

3353. By Daniel van Vugt on 2012-08-09

Rewrote the port of wobbly, this time using GLVertexBuffer and glAddGeometry
properly.

3354. By Daniel van Vugt on 2012-08-09

Revert a pointless 1-line change that crept into the gles2 port.

3355. By Sam Spilsbury on 2012-08-09

Currently plugins know too much about GLWindow (eg, they must fetch the
GLWindow::vertexBuffer directly) in order to manipulate its vertices. This
does not make any sense, as the plugins are meant to do that in the
glAddGeometry stage. This refactors the code such that:

Plugins can now no longer directly access GLWindow::vertexBuffer. Instead they
must use:

  GLWindow::clearVertices () to clear all saved vertex data and begin vertex
      collection
  GLWindow::addVertexDataForGeometry () (replacement for glAddGeometry)
  GLWindow::saveVertices () which returns the number of vertices saved.
      Plugins can use this information to optimize out further steps if no
      vertices were saved as the result of the glAddGeometry calls

A GLVertexBuffer is now provided to plugins who wrap glAddGeometry. They can
manipulate that directly.

3356. By Daniel van Vugt on 2012-08-09

Fix build failure caused by previous commit.

Had do disable lighting support for expo curve mode, again. It doesn't work
without GLWindow::vertexBuffer()

3357. By Daniel van Vugt on 2012-08-09

Quick and dirty port of the animation grid. Now it works and Magic Lamp is
once again the default minimize/restore animation.
(LP: #1003255)

It's a little ugly though. Looks like the grid resolution is incorrect.

3358. By Daniel van Vugt on 2012-08-09

grid.cpp: Update author info.

3359. By Sam Spilsbury on 2012-08-10

Sam:
Enables expo for building again, we need to provide a GLVertexBuffer to
glDrawTexture as callers may need to access and modify vertex data there
(even though its a strange place for it to be done).

Daniel:
Fixed build failure in animation and removed a pointless whitespace change
from expo.xml.in

3360. By Daniel van Vugt on 2012-08-10

Add comments explaining strange indentation.

3361. By Daniel van Vugt on 2012-08-10

Fixed animation grid resolution. Now Magic Lamp curves are smooth again.
(LP: #1034838)

3362. By Daniel van Vugt on 2012-08-10

Corrected detection of mipmap support. Now it works, mostly...
It works for switcher and cube unfold. It's broken slightly for expo, but
only for windows you've never focussed before the expo.
(LP: #1020818)

3363. By Daniel van Vugt on 2012-08-13

Don't generate mipmaps unless EXT_texture_from_pixmap says it is safe.

This fixes conformance LP: #1035212 and unfortunately regresses LP: #1020818.

For some reason, Mesa/Intel does not advertise support for
GLX_BIND_TO_MIPMAP_TEXTURE_EXT in any FBConfig. So once again we have no
mipmaps on Intel at least. This looks like a driver bug, because the
spec says several times that you can't mipmap a texture_from_pixmap unless
GLX_BIND_TO_MIPMAP_TEXTURE_EXT is set.
[http://www.opengl.org/registry/specs/EXT/texture_from_pixmap.txt]

3364. By Daniel van Vugt on 2012-08-13

Bump COMPIZ_OPENGL_ABI to 5, since much of the opengl plugin interface has
changed now.

3365. By Daniel van Vugt on 2012-08-14

Merge latest lp:compiz and fix a conflict.

3366. By Daniel van Vugt on 2012-08-14

Revert API changes, for several reasons:

  1. They are making the unity code unbuildable and agonizing to support
     with #if's everywhere. I started trying to port lp:unity to support
     the API changes, and then I realized no one would ever approve it. And
     nor should they.

  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.

  3. The changes are not required to deliver GLES to trunk. They do not fix
     any bugs, or solve any design problem that doesn't already exist in
     trunk.

3367. By Daniel van Vugt on 2012-08-14

#define USE_MODERN_COMPIZ_GL so Unity builds switch APIs automatically and
don't fail to build with cryptic errors.

3368. By Daniel van Vugt on 2012-08-16

Merge latest lp:compiz

3369. By Daniel van Vugt on 2012-08-16

Improved fix for scale rendering artefacts, caused by buffer swapping combined
with shadows redrawing outside of the damage region.
(LP: #1037489) (LP: #1026986)

3370. By Daniel van Vugt on 2012-08-17

Comment out a nasty SGX/ARM/GLES workaround, which was telling windows they
are allowed to paint beyond the damage region. We should never do that
because then we lose track of what has been drawn and what needs redrawing.
(LP: #1036520)

This might fix some of the shadow overdraw bugs too.

3371. By Sam Spilsbury on 2012-08-21

Fix build failure on USE_GLES

3372. By Daniel van Vugt on 2012-08-21

Allow user-provided values for CMAKE_MODULE_PATH. For example, this is
required to find FindOpenGLES2.cmake when building Unity with
-DBUILD_GLES=ON
(LP: #1039448)

3373. By Sam Spilsbury on 2012-08-22

Merge trunk

3374. By Daniel van Vugt on 2012-08-22

Merge latest lp:compiz

3375. By Daniel van Vugt on 2012-08-22

Merge latest lp:compiz

3376. By Daniel van Vugt on 2012-08-22

Fix simple build failure, due to massive incompatible changes being merged
in from lp:compiz.
(LP: #1039876)

3377. By Daniel van Vugt on 2012-08-22

Ported rectangle resize mode. It was non-functional, with:
  - No blending
  - Incorrect colouring
  - Flickering (due to no damage)
(LP: #1039880)

3378. By Daniel van Vugt on 2012-08-22

Merged latest lp:compiz

Unmerged revisions

=== modified file 'cmake/CMakeLists.txt'
--- cmake/CMakeLists.txt	2012-07-29 03:23:28 +0000
+++ cmake/CMakeLists.txt	2012-08-10 06:51:23 +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-02 23:42:20 +0000
+++ cmake/CompizCommon.cmake	2012-08-10 06:51:23 +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-10 06:51:23 +0000
@@ -257,6 +257,16 @@
 	    NO_DEFAULT_PATH
 	)
 
+	set (COMPIZ_CURRENT_PLUGIN ${plugin})
+	set (COMPIZ_CURRENT_XML_FILE ${_translated_xml})
+
+	# find extension files
+	file (GLOB _extension_files "${COMPIZ_CMAKE_MODULE_PATH}/plugin_extensions/*.cmake")
+
+	foreach (_file ${_extension_files})
+	    include (${_file})
+	endforeach ()
+
 	# generate pkgconfig file and install it and the plugin header file
 	if (_${plugin}_pkg AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/include/${plugin})
 	    if ("${PLUGIN_BUILDTYPE}" STREQUAL "local")
@@ -269,11 +279,15 @@
 		    set (VERSION 0.0.1-git)
 		endif (NOT VERSION)
 
+		#add CFLAGSADD so pkg-config file has correct flags
+		set (COMPIZ_CFLAGS ${COMPIZ_CFLAGS} ${${_PLUGIN}_CFLAGSADD})
+
 		compiz_configure_file (
 		    ${_${plugin}_pkg}
 		    ${CMAKE_BINARY_DIR}/generated/compiz-${plugin}.pc
 		    COMPIZ_REQUIRES
 		    COMPIZ_CFLAGS
+		    PKGCONFIG_LIBS
 		)
 
 		install (
@@ -287,16 +301,6 @@
 	    endif ()
 	endif ()
 
-	set (COMPIZ_CURRENT_PLUGIN ${plugin})
-	set (COMPIZ_CURRENT_XML_FILE ${_translated_xml})
-
-	# find extension files
-	file (GLOB _extension_files "${COMPIZ_CMAKE_MODULE_PATH}/plugin_extensions/*.cmake")
-
-	foreach (_file ${_extension_files})
-	    include (${_file})
-	endforeach ()
-
 	# find files for build
 	file (GLOB _h_files "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")
 	file (GLOB _h_ins_files "${CMAKE_CURRENT_SOURCE_DIR}/include/${plugin}/*.h")

=== added file 'cmake/FindOpenGLES2.cmake'
--- cmake/FindOpenGLES2.cmake	1970-01-01 00:00:00 +0000
+++ cmake/FindOpenGLES2.cmake	2012-08-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +0000
@@ -1,7 +1,5 @@
 find_package (Compiz REQUIRED)
 include (CompizPlugin)
-include (FindOpenGL)
-
-if (OPENGL_GLU_FOUND)
-    compiz_plugin (animation PLUGINDEPS composite opengl LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
+
+compiz_plugin (animation PLUGINDEPS composite opengl)
+

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

=== modified file 'plugins/animation/include/animation/animeffect.h'
--- plugins/animation/include/animation/animeffect.h	2012-04-10 06:13:37 +0000
+++ plugins/animation/include/animation/animeffect.h	2012-08-10 06:51:23 +0000
@@ -72,7 +72,7 @@
     
     int mOverrideProgressDir;	///< 0: default dir, 1: forward, 2: backward
     
-    GLFragment::Attrib mCurPaintAttrib;
+    GLWindowPaintAttrib mCurPaintAttrib;
     GLushort mStoredOpacity;
     WindowEvent mCurWindowEvent;
     bool mInitialized; ///< whether the animation is initialized (in preparePaint)
@@ -155,7 +155,8 @@
 				int dwidth, int dheight) { return true; }
 
     virtual void adjustPointerIconSize () {}
-    virtual void addGeometry (const GLTexture::MatrixList &matrix,
+    virtual void addGeometry (GLVertexBuffer		&vertexBuffer,
+			      const GLTexture::MatrixList &matrix,
 			    const CompRegion            &region,
 			    const CompRegion            &clip,
 			    unsigned int                maxGridWidth,
@@ -179,7 +180,7 @@
     virtual ExtensionPluginInfo *getExtensionPluginInfo ();
 
     void drawTexture (GLTexture          *texture,
-		      GLFragment::Attrib &attrib,
+                      const GLWindowPaintAttrib &attrib,
 		      unsigned int       mask);
 
     // Utility methods
@@ -205,7 +206,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-10 06:51:23 +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; }
@@ -98,7 +96,8 @@
     void init ();
     void updateBB (CompOutput &output);
     bool updateBBUsed () { return true; }
-    void addGeometry (const GLTexture::MatrixList &matrix,
+    void addGeometry (GLVertexBuffer              &vertexBuffer,
+		      const GLTexture::MatrixList &matrix,
 		      const CompRegion            &region,
 		      const CompRegion            &clip,
 		      unsigned int                maxGridWidth,

=== modified file 'plugins/animation/include/animation/partialwindow.h'
--- plugins/animation/include/animation/partialwindow.h	2010-08-17 21:19:04 +0000
+++ plugins/animation/include/animation/partialwindow.h	2012-08-10 06:51:23 +0000
@@ -11,7 +11,8 @@
 		       const AnimEffect info,
 		       const CompRect &icon);
     
-    void addGeometry (const GLTexture::MatrixList &matrix,
+    void addGeometry (GLVertexBuffer &vertexBuffer,
+		      const GLTexture::MatrixList &matrix,
 		      const CompRegion            &region,
 		      const CompRegion            &clip,
 		      unsigned int                maxGridWidth,

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2012-07-30 12:43:11 +0000
+++ plugins/animation/src/animation.cpp	2012-08-10 06:51:23 +0000
@@ -26,6 +26,10 @@
  * Particle system added by : (C) 2006 Dennis Kasprzyk
  * E-mail                   : [e-mail]
  *
+ * Ported to GLES by : Travis Watkins
+ *                     (C) 2011 Linaro Limited
+ * E-mail            : [e-mail]
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
@@ -80,8 +84,9 @@
  *
  */
 
-#include <GL/glu.h>
 #include <core/atoms.h>
+#include <core/core.h>
+#include <opengl/opengl.h>
 #include <sys/time.h>
 #include <assert.h>
 #include "private.h"
@@ -802,6 +807,58 @@
 		       coordsTransformed[GLVector::y]);
 }
 
+static bool
+project (float objx, float objy, float objz, 
+         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,
@@ -810,27 +867,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);
@@ -841,11 +895,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);
@@ -901,15 +956,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 &
@@ -1430,12 +1480,13 @@
 {
     gWindow->glPaintSetEnabled (this, enabling);
     gWindow->glAddGeometrySetEnabled (this, enabling);
-    gWindow->glDrawGeometrySetEnabled (this, enabling);
+    //gWindow->glDrawGeometrySetEnabled (this, enabling);
     gWindow->glDrawTextureSetEnabled (this, enabling);
 }
 
 void
-PrivateAnimWindow::glAddGeometry (const GLTexture::MatrixList &matrix,
+PrivateAnimWindow::glAddGeometry (GLVertexBuffer	      &vertexBuffer,
+				  const GLTexture::MatrixList &matrix,
 				  const CompRegion            &region,
 				  const CompRegion            &clip,
 				  unsigned int                maxGridWidth,
@@ -1445,12 +1496,12 @@
     if (mCurAnimation)
     {
 	if (mCurAnimation->initialized ())
-	    mCurAnimation->addGeometry (matrix, region, clip,
+	    mCurAnimation->addGeometry (vertexBuffer, matrix, region, clip,
 					maxGridWidth, maxGridHeight);
     }
     else
     {
-	gWindow->glAddGeometry (matrix, region, clip,
+	gWindow->glAddGeometry (vertexBuffer, matrix, region, clip,
 				maxGridWidth, maxGridHeight);
     }
 }
@@ -1472,18 +1523,21 @@
 }
 
 void
-Animation::addGeometry (const GLTexture::MatrixList &matrix,
+Animation::addGeometry (GLVertexBuffer &vertexBuffer,
+			const GLTexture::MatrixList &matrix,
 			const CompRegion            &region,
 			const CompRegion            &clip,
 			unsigned int                maxGridWidth,
 			unsigned int                maxGridHeight)
 {
-    mAWindow->priv->gWindow->glAddGeometry (matrix, region, clip,
+    mAWindow->priv->gWindow->glAddGeometry (vertexBuffer,
+					    matrix, region, clip,
 					    maxGridWidth, maxGridHeight);
 }
 
 void
-PartialWindowAnim::addGeometry (const GLTexture::MatrixList &matrix,
+PartialWindowAnim::addGeometry (GLVertexBuffer		    &vertexBuffer,
+				const GLTexture::MatrixList &matrix,
 				const CompRegion            &region,
 				const CompRegion            &clip,
 				unsigned int                maxGridWidth,
@@ -1492,19 +1546,21 @@
     if (mUseDrawRegion)
     {
 	CompRegion awRegion (region.intersected (mDrawRegion));
-	Animation::addGeometry (matrix, awRegion, clip,
+	Animation::addGeometry (vertexBuffer, matrix, awRegion, clip,
 				maxGridWidth, maxGridHeight);
     }
     else
     {
-	Animation::addGeometry (matrix, region, clip,
+	Animation::addGeometry (vertexBuffer, matrix, region, clip,
 				maxGridWidth, maxGridHeight);
     }
 }
 
 void
-PrivateAnimWindow::glDrawTexture (GLTexture          *texture,
-				  GLFragment::Attrib &attrib,
+PrivateAnimWindow::glDrawTexture (GLVertexBuffer     &vertexBuffer,
+				  GLTexture          *texture,
+                                  const GLMatrix     &transform,
+                                  const GLWindowPaintAttrib &attrib,
 				  unsigned int       mask)
 {
     if (mCurAnimation)
@@ -1512,9 +1568,10 @@
 	mCurAnimation->setCurPaintAttrib (attrib);
     }
 
-    gWindow->glDrawTexture (texture, attrib, mask);
+    gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 }
 
+#if 0 // Not ported yet
 void
 PrivateAnimWindow::glDrawGeometry ()
 {
@@ -1528,10 +1585,11 @@
 	gWindow->glDrawGeometry ();
     }
 }
+#endif
 
 void
 Animation::drawTexture (GLTexture          *texture,
-			GLFragment::Attrib &attrib,
+                        const GLWindowPaintAttrib &attrib,
 			unsigned int       mask)
 {
     mCurPaintAttrib = attrib;
@@ -1540,7 +1598,9 @@
 void
 Animation::drawGeometry ()
 {
+#if 0 // Not ported yet
     mAWindow->priv->gWindow->glDrawGeometry ();
+#endif
 }
 
 bool
@@ -1609,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-10 06:51:23 +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
@@ -211,40 +213,26 @@
 }
 
 void
-GridAnim::addGeometry (const GLTexture::MatrixList &matrix,
+GridAnim::addGeometry (GLVertexBuffer              &vertexBuffer,
+		       const GLTexture::MatrixList &matrix,
 		       const CompRegion            &region,
 		       const CompRegion            &clip,
 		       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 +250,13 @@
     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 ();
+    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 +281,24 @@
 	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;
-
+	GLWindow *gWindow = GLWindow::get (mWindow);
+	int oldCount = vertexBuffer.countVertices ();
+	gWindow->glAddGeometry (vertexBuffer, 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 +306,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 +313,6 @@
 			(mDecorBottomHeight ? (y - winContentsY -
 					       winContentsHeight) /
 			 mDecorBottomHeight : 0);
-		    applyOffsets = false;
 		}
 		else		// in window contents (only in Y coords)
 		{
@@ -406,8 +335,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 +389,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-10 06:51:23 +0000
@@ -404,12 +404,13 @@
     // GLWindowInterface methods
     bool glPaint (const GLWindowPaintAttrib &, const GLMatrix &,
 		  const CompRegion &, unsigned int);
-    void glAddGeometry (const GLTexture::MatrixList &,
+    void glAddGeometry (GLVertexBuffer &,
+			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 (GLVertexBuffer &vertexBuffer, 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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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->clearVertices ();
 
 	gWindow->glAddGeometrySetCurrentIndex (MAXSHORT);
-	gWindow->glAddGeometry (matrix, iconReg, infiniteRegion);
+	gWindow->addVertexDataForGeometry (matrix, iconReg, infiniteRegion);
 	gWindow->glAddGeometrySetCurrentIndex (addWindowGeometryIndex);
 
-	if (gWindow->geometry ().vCount)
+	if (gWindow->saveVertices ())
 	{
-	    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->glDrawTextureWithInternalVertexBuffer (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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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->clearVertices ();
 	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 ();
 
@@ -259,13 +254,17 @@
 	    {
 		ml[0] = wd->quad[i].matrix;
 		const CompRegionRef boxRegion (box.region ());
-		gWindow->glAddGeometry (ml, boxRegion, reg);
+		gWindow->addVertexDataForGeometry (ml, boxRegion, reg);
 	    }
 	}
 
-	if (gWindow->geometry ().vCount)
-	    gWindow->glDrawTexture (wd->decor->texture->textures[0],
+	if (gWindow->saveVertices ())
+	{
+	    glEnable (GL_BLEND);
+	    gWindow->glDrawTextureWithInternalVertexBuffer (wd->decor->texture->textures[0], transform,
 				    attrib, mask);
+	    glDisable (GL_BLEND);
+	}
     }
     else if (wd && wd->decor->type == WINDOW_DECORATION_TYPE_WINDOW)
     {
@@ -279,14 +278,18 @@
 	if (updateMatrix)
 	    updateDecorationScale ();
 
+	glEnable (GL_BLEND);
+
 	if (gWindow->textures ().size () == 1)
 	{
 	    ml[0] = gWindow->matrices ()[0];
-	    gWindow->geometry ().reset ();
-	    gWindow->glAddGeometry (ml, window->frameRegion (), region);
-
-	    if (gWindow->geometry ().vCount)
-		gWindow->glDrawTexture (gWindow->textures ()[0], attrib, mask);
+
+	    gWindow->clearVertices ();
+	    gWindow->addVertexDataForGeometry (ml, window->frameRegion (), region);
+
+	    if (gWindow->saveVertices ())
+		gWindow->glDrawTextureWithInternalVertexBuffer (gWindow->textures ()[0], transform,
+		                        attrib, mask);
 	}
 	else
 	{
@@ -295,14 +298,17 @@
 	    for (unsigned int i = 0; i < gWindow->textures ().size (); i++)
 	    {
 		ml[0] = gWindow->matrices ()[i];
-		gWindow->geometry ().reset ();
-		gWindow->glAddGeometry (ml, regions[i], region);
-
-		if (gWindow->geometry ().vCount)
-		    gWindow->glDrawTexture (gWindow->textures ()[i], attrib,
-					    mask);
+
+		gWindow->clearVertices ();
+		gWindow->addVertexDataForGeometry (ml, regions[i], region);
+
+		if (gWindow->saveVertices ())
+		    gWindow->glDrawTextureWithInternalVertexBuffer (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-10 06:51:23 +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-05-16 17:40:58 +0000
+++ plugins/expo/CMakeLists.txt	2012-08-10 06:51:23 +0000
@@ -1,7 +1,4 @@
 find_package (Compiz REQUIRED)
-include (FindOpenGL)
 include (CompizPlugin)
 
-if (OPENGL_GLU_FOUND)
-    compiz_plugin (expo PLUGINDEPS composite opengl LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
+compiz_plugin (expo PLUGINDEPS composite opengl)

=== modified file 'plugins/expo/src/expo.cpp'
--- plugins/expo/src/expo.cpp	2012-05-28 06:08:02 +0000
+++ plugins/expo/src/expo.cpp	2012-08-10 06:51:23 +0000
@@ -4,12 +4,14 @@
  *
  * expo.c
  *
+ * Copyright (c) 2011 Linaro Limited
  * Copyright (c) 2008 Dennis Kasprzyk <[e-mail]>
  * Copyright (c) 2006 Robert Carr <[e-mail]>
  *
  * Authors:
  * Robert Carr <[e-mail]>
  * Dennis Kasprzyk <[e-mail]>
+ * Travis Watkins <[e-mail]>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -25,7 +27,9 @@
 
 #include "expo.h"
 #include <math.h>
+#ifndef USE_GLES
 #include <GL/glu.h>
+#endif
 #include <X11/cursorfont.h>
 
 COMPIZ_PLUGIN_20090315 (expo, ExpoPluginVTable);
@@ -627,6 +631,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,
@@ -634,8 +687,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;
 
@@ -643,16 +695,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];
@@ -706,6 +755,8 @@
 		       unsigned int               mask,
 		       bool                       reflection)
 {
+    GLfloat vertexData[12];
+    GLushort colorData[16];
     GLMatrix sTransformW, sTransform (transform);
     int      i, j, vp;
     GLenum   oldFilter = gScreen->textureFilter ();
@@ -726,6 +777,8 @@
     int      glPaintTransformedOutputIndex =
 	gScreen->glPaintTransformedOutputGetCurrentIndex ();
 
+    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+
     // Make sure that the base glPaintTransformedOutput function is called
     gScreen->glPaintTransformedOutputSetCurrentIndex (MAXSHORT);
 
@@ -818,7 +871,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);
 
@@ -953,73 +1006,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;
@@ -1080,14 +1229,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 ();
@@ -1095,7 +1244,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 ())
@@ -1103,34 +1252,35 @@
 	    if (expoAnimation == ExpoScreen::ExpoAnimationZoom &&
 		eScreen->paintingVp == eScreen->selectedVp)
 	    {
-		fA.setOpacity (fragment.getOpacity () *
-			       (1 - sigmoidProgress (eScreen->expoCam)));
+		eAttrib.opacity = attrib.opacity *
+		                      (1 - sigmoidProgress (eScreen->expoCam));
 	    }
 	    else
 	    {
-		fA.setOpacity (0);
+		eAttrib.opacity = 0;
 	    }
 	}
 
-	fA.setBrightness (fragment.getBrightness () * eScreen->vpBrightness);
-	fA.setSaturation (fragment.getSaturation () * eScreen->vpSaturation);
+	eAttrib.brightness = attrib.brightness * eScreen->vpBrightness;
+	eAttrib.saturation = attrib.saturation * eScreen->vpSaturation;
     }
     else
     {
 	if (expoAnimation == ExpoScreen::ExpoAnimationZoom)
-	    fA.setBrightness (0);
+	    eAttrib.brightness = 0;
 	else
-	    fA.setBrightness (fragment.getBrightness () *
-			      (1 - sigmoidProgress (eScreen->expoCam)));
+	    eAttrib.brightness = attrib.brightness *
+	                              (1 - sigmoidProgress (eScreen->expoCam));
     }
 
-    return gWindow->glDraw (transform, fA, region, mask);
+    return gWindow->glDraw (transform, eAttrib, region, mask);
 }
 
 #define EXPO_GRID_SIZE 100
 
 void
-ExpoWindow::glAddGeometry (const GLTexture::MatrixList& matrices,
+ExpoWindow::glAddGeometry (GLVertexBuffer               &vertexBuffer,
+			   const GLTexture::MatrixList& matrices,
 			   const CompRegion&            region,
 			   const CompRegion&            clip,
 			   unsigned int                 maxGridWidth,
@@ -1140,20 +1290,22 @@
 	screen->desktopWindowCount () &&
 	eScreen->optionGetDeform () == ExpoScreen::DeformCurve)
     {
-	int         i, oldVCount = gWindow->geometry ().vCount;
+	int         i, oldVCount = vertexBuffer.countVertices ();
 	GLfloat     *v;
 	CompPoint   offset;
 	float       lastX, lastZ = 0.0;
 	const float radSquare = pow (eScreen->curveDistance, 2) + 0.25;
 	float       ang;
 
-	gWindow->glAddGeometry (matrices, region, clip,
+	gWindow->glAddGeometry (vertexBuffer,
+				matrices, region, clip,
 				MIN(maxGridWidth , EXPO_GRID_SIZE),
 				maxGridHeight);
 
-	v  = gWindow->geometry ().vertices;
-	v += gWindow->geometry ().vertexStride - 3;
-	v += gWindow->geometry ().vertexStride * oldVCount;
+	int stride = vertexBuffer.getVertexStride ();
+	v  = vertexBuffer.getVertices ();
+	v += stride - 3;
+	v += stride * oldVCount;
 
 	if (!window->onAllViewports ())
 	{
@@ -1163,7 +1315,7 @@
 
 	lastX = -1000000000.0;
 
-	for (i = oldVCount; i < gWindow->geometry ().vCount; i++)
+	for (i = oldVCount; i < vertexBuffer.countVertices (); i++)
 	{
 	    if (v[0] == lastX)
 	    {
@@ -1184,18 +1336,20 @@
 	    lastX = v[0];
 	    lastZ = v[2];
 
-	    v += gWindow->geometry ().vertexStride;
+	    v += stride;
 	}
     }
     else
     {
-	gWindow->glAddGeometry (matrices, region, clip, maxGridWidth, maxGridHeight);
+	gWindow->glAddGeometry (vertexBuffer, matrices, region, clip, maxGridWidth, maxGridHeight);
     }
 }
 
 void
-ExpoWindow::glDrawTexture (GLTexture           *texture,
-			   GLFragment::Attrib& attrib,
+ExpoWindow::glDrawTexture (GLVertexBuffer	     &vertexBuffer,
+			   GLTexture		     *texture,
+                           const GLMatrix            &transform,
+                           const GLWindowPaintAttrib &attrib,
 			   unsigned int        mask)
 {
     if (eScreen->expoCam > 0.0                                 &&
@@ -1203,15 +1357,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 = &vertexBuffer;
 
 	if (!window->onAllViewports ())
 	{
@@ -1219,44 +1367,37 @@
 	    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;
 	}
 
 	glEnable (GL_NORMALIZE);
-	glNormalPointer (GL_FLOAT,0, &eScreen->winNormals.at (0));
-
-	glEnableClientState (GL_NORMAL_ARRAY);
-
-	gWindow->glDrawTexture (texture, attrib, mask);
-
+	gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 	glDisable (GL_NORMALIZE);
-	glDisableClientState (GL_NORMAL_ARRAY);
-	glNormal3f (0.0, 0.0, -1.0);
     }
     else
     {
-	glEnable (GL_NORMALIZE);
-	gWindow->glDrawTexture (texture, attrib, mask);
-	glDisable (GL_NORMALIZE);
+//	glEnable (GL_NORMALIZE);
+	gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
+//	glDisable (GL_NORMALIZE);
     }
 }
 

=== modified file 'plugins/expo/src/expo.h'
--- plugins/expo/src/expo.h	2012-05-28 05:35:38 +0000
+++ plugins/expo/src/expo.h	2012-08-10 06:51:23 +0000
@@ -109,7 +109,6 @@
 	float curveRadius;
 
 	std::vector<GLfloat> vpNormals;
-	std::vector<GLfloat> winNormals;
 
 	CompScreen::GrabHandle grabIndex;
 
@@ -141,15 +140,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&,
+	void glAddGeometry (GLVertexBuffer &vertexBuffer, const GLTexture::MatrixList&,
 			    const CompRegion&, const CompRegion&,
 			    unsigned int, unsigned int);
-	void glDrawTexture (GLTexture *, GLFragment::Attrib& attrib,
-			    unsigned int);
+	void glDrawTexture (GLVertexBuffer &vertexBuffer, 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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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,16 @@
 	{
 	    matrix[0] = context->texture[0].matrices[i];
 
-	    gWindow->geometry ().reset ();
-	    gWindow->glAddGeometry (matrix, context->box, reg);
-
-	    if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
-		mask |= PAINT_WINDOW_BLEND_MASK;
-
-	    gWindow->glDrawTexture (context->texture[0].textures[i], fragment, mask);
+	    gWindow->clearVertices ();
+	    gWindow->addVertexDataForGeometry (matrix, context->box, reg);
+	    if (gWindow->saveVertices ())
+	    {
+		if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
+		    mask |= PAINT_WINDOW_BLEND_MASK;
+
+		gWindow->glDrawTextureWithInternalVertexBuffer (context->texture[0].textures[i], transform,
+					attrib, mask);
+	    }
 
 	    if (rect.width () > 0 && rect.height () > 0)
 	    {
@@ -321,11 +324,11 @@
 		    saveFilter = gScreen->filter (SCREEN_TRANS_FILTER);
 		    gScreen->setFilter (SCREEN_TRANS_FILTER, GLTexture::Good);
 
-		    gWindow->geometry ().reset ();
-		    gWindow->glAddGeometry (matrix, r, reg);
-
-		    gWindow->glDrawTexture (context->texture[1].textures[j],
-					    fragment, mask);
+		    gWindow->clearVertices ();
+		    gWindow->addVertexDataForGeometry (matrix, r, reg);
+		    if (gWindow->saveVertices ())
+			gWindow->glDrawTextureWithInternalVertexBuffer (context->texture[1].textures[j],
+						transform, attrib, mask);
 
 		    gScreen->setFilter (SCREEN_TRANS_FILTER, saveFilter);
 		}

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

=== modified file 'plugins/kdecompat/src/kdecompat.cpp'
--- plugins/kdecompat/src/kdecompat.cpp	2012-05-27 04:32:55 +0000
+++ plugins/kdecompat/src/kdecompat.cpp	2012-08-10 06:51:23 +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)
@@ -271,6 +264,7 @@
 	unsigned int   paintMask = mask | PAINT_WINDOW_TRANSFORMED_MASK;
 	float          xScale = 1.0f, yScale = 1.0f, xTranslate, yTranslate;
 	GLTexture      *icon = NULL;
+	unsigned int   iconNVertices = 0;
 
 	if (!tw)
 	    continue;
@@ -329,20 +323,20 @@
 		matrices[0].x0 -= (tw->x () * icon->matrix ().xx);
 		matrices[0].y0 -= (tw->y () * icon->matrix ().yy);
 
-		gtw->geometry ().reset ();
-		gtw->glAddGeometry (matrices, tw->geometry (), infiniteRegion);
-
-		if (!gtw->geometry ().vertices)
-		    icon = NULL;
+		gtw->clearVertices ();
+		gtw->addVertexDataForGeometry (matrices, tw->geometry (), infiniteRegion);
+		iconNVertices = gtw->saveVertices ();
 	    }
 	}
 
-	if (!gtw->textures ().empty () || icon)
+	bool canDrawIcon = icon && iconNVertices;
+
+	if (!gtw->textures ().empty () ||
+	    canDrawIcon)
 	{
-	    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 +345,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->glDrawTextureWithInternalVertexBuffer (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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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,13 @@
     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,
+NegWindow::glDrawTexture (GLVertexBuffer	    &vertexBuffer,
+			  GLTexture          *texture,
+                          const GLMatrix            &transform,
+                          const GLWindowPaintAttrib &attrib,
 			  unsigned int       mask)
 {
-    GLTexture::Filter filter;
     bool              doNeg = false;
     GLTexture         *tex = NULL;
 
@@ -160,24 +113,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 (vertexBuffer, 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 +133,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 +174,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 +211,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 +226,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 +255,7 @@
 			glTexEnvf(GL_TEXTURE_ENV,
 				  GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
 
-			/* draw the window geometry */
-			gWindow->glDrawGeometry ();
+			gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 
 			/* disable the current texture */
 			texture->disable ();
@@ -331,8 +271,7 @@
 		    {
 			/* fully opaque and bright */
 
-			/* draw the window geometry */
-			gWindow->glDrawGeometry ();
+			gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 		    }
 
 		    /* disable the current texture */
@@ -355,9 +294,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 +307,7 @@
 
 		    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
 
-    		    /* draw the window geometry */
-		    gWindow->glDrawGeometry ();
+		    gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 		}
 
 		/* disable the current texture */
@@ -390,9 +328,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 +346,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 +373,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 (vertexBuffer, texture, transform, attrib, mask);
 		}
 		else
 		{
 		    /* no adjustments to saturation, brightness or opacity */
 
-		    /* draw the window geometry */
-		    gWindow->glDrawGeometry ();
+		    gWindow->glDrawTexture (vertexBuffer, texture, transform, attrib, mask);
 		}
 
 		/* disable the current texture */
@@ -461,12 +388,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 (vertexBuffer, 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-10 06:51:23 +0000
@@ -57,10 +57,6 @@
 		CompOption::Vector opt,
 		bool		   all);
 
-	int
-	getFragmentFunction (GLTexture *texture,
-			     bool      alpha);
-
 	GLScreen *gScreen;
 };
 
@@ -89,8 +85,10 @@
 	bool isNeg;
 
 	void
-	glDrawTexture(GLTexture          *texture,
-		      GLFragment::Attrib &attrib,
+	glDrawTexture (GLVertexBuffer &vertexBuffer,
+		       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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +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-10 06:51:23 +0000
@@ -28,16 +28,45 @@
 #ifndef _COMPIZ_OPENGL_H
 #define _COMPIZ_OPENGL_H
 
+#ifdef USE_GLES
+#define SUPPORT_X11
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
 #include <GL/gl.h>
 #include <GL/glx.h>
+#endif
+
+#include <core/size.h>
+#include <core/pluginclasshandler.h>
 
 #include <opengl/matrix.h>
 #include <opengl/texture.h>
-#include <opengl/fragment.h>
+#include <opengl/framebufferobject.h>
+#include <opengl/vertexbuffer.h>
+#include <opengl/program.h>
+#include <opengl/programcache.h>
+#include <opengl/shadercache.h>
 
 #define COMPIZ_OPENGL_ABI 4
 
-#include <core/pluginclasshandler.h>
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
+
+#if !defined(GL_BGRA)
+    #if !defined(GL_BGRA_EXT)
+	#error GL_BGRA support is required
+    #else
+	#define GL_BGRA GL_BGRA_EXT
+    #endif
+#endif
 
 /**
  * camera distance from screen, 0.5 * tan (FOV)
@@ -75,8 +104,26 @@
 #endif
 
 namespace GL {
-
+    #ifdef USE_GLES
+    typedef EGLImageKHR (*EGLCreateImageKHRProc)  (EGLDisplay dpy,
+                                                   EGLContext ctx,
+                                                   EGLenum target,
+                                                   EGLClientBuffer buffer,
+                                                   const EGLint *attrib_list);
+    typedef EGLBoolean  (*EGLDestroyImageKHRProc) (EGLDisplay dpy,
+                                                   EGLImageKHR image);
+
+    typedef void (*GLEGLImageTargetTexture2DOESProc) (GLenum target,
+                                                      GLeglImageOES image);
+
+    typedef EGLBoolean (*EGLPostSubBufferNVProc) (EGLDisplay dpy,
+						  EGLSurface surface,
+						  EGLint x, EGLint y,
+						  EGLint width, EGLint height);
+
+    #else
     typedef void (*FuncPtr) (void);
+
     typedef FuncPtr (*GLXGetProcAddressProc) (const GLubyte *procName);
 
     typedef void    (*GLXBindTexImageProc)    (Display	 *display,
@@ -122,11 +169,6 @@
 					      const int   *attribList);
     typedef void      (*GLXDestroyPixmapProc) (Display *display,
     					       GLXPixmap pixmap);
-
-    typedef void (*GLActiveTextureProc) (GLenum texture);
-    typedef void (*GLClientActiveTextureProc) (GLenum texture);
-    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
-
     typedef void (*GLGenProgramsProc) (GLsizei n,
 				       GLuint  *programs);
     typedef void (*GLDeleteProgramsProc) (GLsizei n,
@@ -146,11 +188,16 @@
     typedef void (*GLGetProgramivProc) (GLenum target,
 					GLenum pname,
 					int    *params);
+    #endif
+
+    typedef void (*GLActiveTextureProc) (GLenum texture);
+    typedef void (*GLClientActiveTextureProc) (GLenum texture);
+    typedef void (*GLMultiTexCoord2fProc) (GLenum, GLfloat, GLfloat);
 
     typedef void (*GLGenFramebuffersProc) (GLsizei n,
 					   GLuint  *framebuffers);
     typedef void (*GLDeleteFramebuffersProc) (GLsizei n,
-					      GLuint  *framebuffers);
+					      const GLuint  *framebuffers);
     typedef void (*GLBindFramebufferProc) (GLenum target,
 					   GLuint framebuffer);
     typedef GLenum (*GLCheckFramebufferStatusProc) (GLenum target);
@@ -161,6 +208,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 +349,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 +356,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 +369,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 +554,7 @@
 
 #define MAX_DEPTH 32
 
+#ifndef USE_GLES
 struct GLFBConfig {
     GLXFBConfig fbConfig;
     int         yInverted;
@@ -227,6 +562,7 @@
     int         textureFormat;
     int         textureTargets;
 };
+#endif
 
 #define NOTHING_TRANS_FILTER 0
 #define SCREEN_TRANS_FILTER  1
@@ -236,6 +572,7 @@
 extern GLScreenPaintAttrib defaultScreenPaintAttrib;
 
 class GLScreen;
+class GLFramebufferObject;
 
 class GLScreenInterface :
     public WrapableInterface<GLScreen, GLScreenInterface>
@@ -302,11 +639,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 +690,9 @@
 	/**
 	 * Gets the libGL address of a particular openGL functor
 	 */
+	#ifndef USE_GLES
 	GL::FuncPtr getProcAddress (const char *name);
+	#endif
 
 	void updateBackground ();
 
@@ -346,8 +706,6 @@
 	 */
 	void setFilter (int, GLTexture::Filter);
 
-	GLFragment::Storage * fragmentStorage ();
-
 	/**
 	 * Sets a new compiz-wid openGL texture environment mode
 	 */
@@ -356,7 +714,6 @@
 	/**
 	 * Turns lighting on and off
 	 */
-
 	void setLighting (bool lighting);
 
 	/**
@@ -371,7 +728,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 +758,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 +774,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 +835,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);
 
@@ -474,56 +855,39 @@
 	 * @param min
 	 * @param max
 	 */
-	virtual void glAddGeometry (const GLTexture::MatrixList &matrices,
+	virtual void glAddGeometry (GLVertexBuffer		&vertexBuffer,
+				    const GLTexture::MatrixList &matrices,
 				    const CompRegion 		&region,
 				    const CompRegion 		&clipRegion,
 				    unsigned int		min = MAXSHORT,
 				    unsigned int		max = MAXSHORT);
-	virtual void glDrawTexture (GLTexture *texture, GLFragment::Attrib &,
-				    unsigned int);
-	virtual void glDrawGeometry ();
+
+	/**
+	 * Hookable function to draw a texture with a specified vertexBuffer
+	 * for this window
+	 *
+	 * @brief glDrawTexture
+	 * @param vertexBuffer the vertex buffer containing vertex data to draw
+	 * the texture with
+	 * @param texture the texture to draw
+	 * @param matrix a 3D transformation matrix used to transform the texture
+	 * @param mask paint operations mask