Merge lp:~smspillaz/compiz/compiz.static_vertex_buffers into lp:compiz/0.9.8

[Sam Spilsbury]

Avoid doing so many vertex buffer object binds.

At the moment, all of the vertex buffer objects for windows are marked GL_STATIC_DRAW. However according to http://developer.apple.com/library/ios/#documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/TechniquesforWorkingwithVertexData/TechniquesforWorkingwithVertexData.html , this is a bad idea because doing glBindBuffer and glBufferData on those buffers can cause GPU to copy vertex data from system memory to the GPU on for that vertex buffer every time the command queue is processed. If that's an expensive operation, then it could result in a fairly large slowdown on some platforms. Because the content of our vertex buffers can change a fair bit, I've changed the default usage hint to GL_DYNAMIC_DRAW, which appears to mean "dma data into the gpu, cache it where necessary"

In compiz, we do region updates by clipping vertex data to a clip region (and, eg, generating new vertex and tex-coord data where it makes sense to do so) and then paint only the primitives specified by those vertices. This is easier on GPUs where fill rate is a concern. However, it means that we can't have static data in our vertex buffer objects, and they effectively need to be re-uploaded every time they change.

There were two factors causing them to be changed all the time, which meant that they had to be re-uploaded all the time
 1) Plugins "share" the vertex buffer object with opengl, and clear the vertex data to add their own. This means that both sets have to be re-uploaded, and the opengl one has to be re-populated every time a plugin uses it "temporarily"
 2) A typical usage trend appears to be just calling ::begin (), adding vertex data and then calling ::end (), even if the vertex data is unchanged.

As for 2) I've added a simple check to determine if we need to re-add vertex data at all, and if we don't, not to call glAddGeometry again, but to re-use the vertex buffer (where it makes sense to do). This code is untested, as it involves setting and checking flags and manipulating lots of internal state. Its also not the preferred solution either as per my comments above, which is why I haven't designed the code to be testable around this case.

The result is that for playing a simple video, in the old usecase, we called:
  * glAddGeometry 497 times
  * GLVertexBuffer::end () (eg, vertex data upload if there is vertex data, which there will be for every frame) 745 times

Avoid doing so many vertex buffer object binds. This is more of an RFC than an actual merge proposal as I don't see it going in this cycle.

At the moment, all of the vertex buffer objects for windows are marked GL_STATIC_DRAW. However according to http://developer.apple.com/library/ios/#documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/TechniquesforWorkingwithVertexData/TechniquesforWorkingwithVertexData.html , this is a bad idea because doing glBindBuffer and glBufferData on those buffers can cause GPU to copy vertex data from system memory to the GPU on for that vertex buffer every time the command queue is processed. If that's an expensive operation, then it could result in a fairly large slowdown on some platforms. Because the content of our vertex buffers can change a fair bit, I've changed the default usage hint to GL_DYNAMIC_DRAW, which appears to mean "dma data into the gpu, cache it where necessary"

In compiz, we do region updates by clipping vertex data to a clip region (and, eg, generating new vertex and tex-coord data where it makes sense to do so) and then paint only the primitives specified by those vertices. This is easier on GPUs where fill rate is a concern. However, it means that we can't have static data in our vertex buffer objects, and they effectively need to be re-uploaded every time they change.

There were two factors causing them to be changed all the time, which meant that they had to be re-uploaded all the time
 1) Plugins "share" the vertex buffer object with opengl, and clear the vertex data to add their own. This means that both sets have to be re-uploaded, and the opengl one has to be re-populated every time a plugin uses it "temporarily"
 2) A typical usage trend appears to be just calling ::begin (), adding vertex data and then calling ::end (), even if the vertex data is unchanged.

As for 1) This would best be served by breaking the API and making a GLVertexBuffer * a mandatory part of glAddGeometry and glDrawTexture, so that plugins can provide their own vertex buffers without clobbering the opengl one. Since we can't do that, I've added an API to manipulate which GLVertexBuffer the opengl plugin is using internally. This code is a separate module and covered by unit tests

As for 2) I've added a simple check to determine if we need to re-add vertex data at all, and if we don't, not to call glAddGeometry again, but to re-use the vertex buffer (where it makes sense to do). This code is untested, as it involves setting and checking flags and manipulating lots of internal state. Its also not the preferred solution either as per my comments above, which is why I haven't designed the code to be testable around this case.

The result is that for playing a simple video, in the old usecase, we called:
  * glAddGeometry 497 times
  * GLVertexBuffer::end () (eg, vertex data upload if there is vertex data, which there will be for every frame) 745 times

And for the new code:
 * glAddGeometry 13 times
 * GLVertexBuffer::end () 262 times

I'm not sure what kind of impact this has on framerates. In both cases I maxed out at 60fps.

Where to go with this?
 * The next place that is calling GLVertexBuffer::end () a lot is PrivateGLScreen::paintOutputs when drawing the fbo to the screen. This can be resolved by actually treating that like a static buffer as well (it really should be), or moving to glBlitFramebuffer (preferred
 * We need to make the decor plugin implement the same logic in 2)
 * Make the other plugins provide their own vertex buffers where they need to "attach" textures to windows rather than piggybacking the one internal to opengl.

tl;dr; This might make compiz faster at watching youtube videos. Need feedback as to whether to continue in this direction.

[jenkins (martin-mrazik+qa)]

PASSED: Continuous integration, rev:3363
http://jenkins.qa.ubuntu.com/job/compiz-ci/57/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/compiz-ci/./build=pbuilder,distribution=quantal,flavor=amd64/57/console

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Argh, so many words.

Initial observation: If a class is called "VertexBufferStack" then its method names should not contain the redundant text "VertexBuffer".

[Sam Spilsbury (smspillaz)]

This doesn't need review right away. Just seeking feedback as to whether or not this is the right direction to go

[Daniel van Vugt (vanvugt)]

Awesome speedup on intel. This is 15-25% faster than trunk there. And it matches the max performance levels I have ever seen on my my desktop.

I honestly never thought I would see the FBO+VBO codepath perform this well... I'd like to make this enhancement a priority.

[Daniel van Vugt (vanvugt)]

Linked to bug 1024304, because I suspect this might be the answer. It certainly is for Intel Sandy Bridge.

[Daniel van Vugt (vanvugt)]

This is weird. Suddenly trunk is as fast. Maybe I got prematurely excited but it's still interesting.

[Daniel van Vugt (vanvugt)]

The speedup I thought I got from this was a false alarm. My whole system is suddenly faster with all branches. It wasn't anything to do with this one.

As far as I can tell, this is not required for quantal. So please repropose it after we've branched for 0.9.9.

review: Needs Resubmitting

Unmerged revisions

3363. By Sam Spilsbury on 2012-09-09

Don't call glAddGeometry if the geometry is
going to be exactly the same. Saves a vertex
buffer bind

3362. By Sam Spilsbury on 2012-09-09

Only remove the last vertex buffer when using the stack

3361. By Sam Spilsbury on 2012-09-09

Use GL_DYNAMIC_DRAW for the vertex buffer objects

3360. By Sam Spilsbury on 2012-09-08

Use a foreign vertex buffer to draw the decorations

3359. By Sam Spilsbury on 2012-09-08

Implement the interface publicly

3358. By Sam Spilsbury on 2012-09-08

Implement the internal vertex buffer in terms of the vertex buffer stack

3357. By Sam Spilsbury on 2012-09-08

Added a simple RAII class to manage that

3356. By Sam Spilsbury on 2012-09-08

Added a new class, VertexBufferStack.

A VertexBufferStack is a stack of saved GLVertexBufferObjects, which can have
items pushed to the back, removed and popped off the top. activeVertexBuffer
always represents the top most vertex buffer on the stack, popVertexBufferOffTop
will restore the last one.

3355. By Sam Spilsbury on 2012-09-08

Internally added the concepts of multiple vertex buffers per window

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2012-08-14 06:33:22 +0000
+++ plugins/decor/src/decor.cpp	2012-09-09 16:26:19 +0000
@@ -42,6 +42,8 @@
 
 COMPIZ_PLUGIN_20090315 (decor, DecorPluginVTable)
 
+namespace cgl = compiz::opengl;
+
 MatchedDecorClipGroup::MatchedDecorClipGroup (const CompMatch &match) :
     mMatch (match)
 {
@@ -209,6 +211,9 @@
 		         const CompRegion   &region,
 		         unsigned int       mask)
 {
+    cgl::VertexBufferPush vertexBufferPush (gWindow->vertexBufferStack (),
+					    mDecorationVertexBuffer);
+
     if (wd &&
 	wd->decor->type == WINDOW_DECORATION_TYPE_PIXMAP)
     {
@@ -3091,8 +3096,10 @@
     mClipGroup (NULL),
     mOutputRegion (window->outputRect ()),
     mInputRegion (window->inputRect ()),
-    mRequestor (screen->dpy (), w->id (), &decor)
+    mRequestor (screen->dpy (), w->id (), &decor),
+    mDecorationVertexBuffer (new GLVertexBuffer (GL_STATIC_DRAW))
 {
+    mDecorationVertexBuffer->setAutoProgram (gWindow->autoProgram ());
     WindowInterface::setHandler (window);
 
     /* FIXME :DecorWindow::update can call updateWindowOutputExtents
 
=== modified file 'plugins/decor/src/decor.h'
--- plugins/decor/src/decor.h	2012-07-30 07:10:52 +0000
+++ plugins/decor/src/decor.h	2012-09-09 16:26:19 +0000
@@ -31,6 +31,7 @@
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
+#include <opengl/vertexbufferstack.h>
 #include <core/atoms.h>
 #include <core/windowextents.h>
 
@@ -362,6 +363,7 @@
 	CompRegion              mInputRegion;
 
 	X11DecorPixmapRequestor   mRequestor;
+	compiz::opengl::GLVertexBufferPtr mDecorationVertexBuffer;
 };
 
 class DecorPluginVTable :
 
=== modified file 'plugins/opengl/CMakeLists.txt'
--- plugins/opengl/CMakeLists.txt	2012-09-04 10:19:19 +0000
+++ plugins/opengl/CMakeLists.txt	2012-09-09 16:26:19 +0000
@@ -5,10 +5,17 @@
 set (INTERNAL_LIBRARIES
     compiz_opengl_double_buffer
     compiz_opengl_fsregion
+    compiz_opengl_vertex_buffer_stack
 )
 
+set (COMPIZ_OPENGL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+set (COMPIZ_OPENGL_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
 add_subdirectory (src/doublebuffer)
 add_subdirectory (src/fsregion)
+add_subdirectory (src/vertexbufferstack)
+
+include_directories (src/vertexbufferstack/include)
 
 if (USE_GLES)
     compiz_plugin(opengl PLUGINDEPS composite CFLAGSADD "-DUSE_GLES -std=c++0x" LIBRARIES ${OPENGLES2_LIBRARIES} ${INTERNAL_LIBRARIES} dl INCDIRS ${OPENGLES2_INCLUDE_DIR})
 
=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2012-08-14 08:42:15 +0000
+++ plugins/opengl/include/opengl/opengl.h	2012-09-09 16:26:19 +0000
@@ -39,6 +39,9 @@
 #include <GL/glx.h>
 #endif
 
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
 #include <core/size.h>
 #include <core/pluginclasshandler.h>
 
@@ -871,6 +874,16 @@
 	                            const GLWindowPaintAttrib &, unsigned int);
 };
 
+namespace compiz
+{
+    namespace opengl
+    {
+	typedef boost::shared_ptr <GLVertexBuffer> GLVertexBufferPtr;
+	typedef boost::weak_ptr <GLVertexBuffer> GLVertexBufferWeak;
+	class VertexBufferStack;
+    }
+}
+
 class GLWindow :
     public WrapableHandler<GLWindowInterface, 4>,
     public PluginClassHandler<GLWindow, CompWindow, COMPIZ_OPENGL_ABI>
@@ -926,6 +939,23 @@
 	GLVertexBuffer * vertexBuffer ();
 
 	/**
+	 * Returns the current vertex buffer stack
+	 */
+	compiz::opengl::VertexBufferStack &
+	vertexBufferStack ();
+
+	/**
+	 * Returns the AutoProgram used for this window's
+	 * GLVertexBuffer objects. The returned object
+	 * is internal to GLWindow and should not be
+	 * deleted
+	 *
+	 * TODO ABI: Return weak pointer
+	 */
+	compiz::gl::AutoProgram *
+	autoProgram ();
+
+	/**
 	 * Add a vertex and/or fragment shader function to the pipeline.
 	 *
 	 * @param name Name of the plugin adding the functions
 
=== added file 'plugins/opengl/include/opengl/vertexbufferstack.h'
--- plugins/opengl/include/opengl/vertexbufferstack.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/include/opengl/vertexbufferstack.h	2012-09-09 16:26:19 +0000
@@ -0,0 +1,69 @@
+/*
+ * Compiz opengl plugin, VertexBufferStack interface
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * Author: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef __COMPIZ_OPENGL_VERTEXBUFFERSTACK_H
+#define __COMPIZ_OPENGL_VERTEXBUFFERSTACK_H
+
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+class GLVertexBuffer;
+
+namespace compiz
+{
+    namespace opengl
+    {
+	typedef boost::shared_ptr <GLVertexBuffer> GLVertexBufferPtr;
+	typedef boost::weak_ptr <GLVertexBuffer> GLVertexBufferWeak;
+
+	class VertexBufferStack
+	{
+	    public:
+
+		virtual ~VertexBufferStack () {}
+
+		virtual void pushVertexBuffer (const GLVertexBufferPtr &) = 0;
+		virtual bool removeVertexBuffer (const GLVertexBufferPtr &) = 0;
+		virtual bool removeLastVertexBuffer (const GLVertexBufferPtr &) = 0;
+		virtual void popVertexBufferFromTop () = 0;
+		virtual const GLVertexBufferWeak & activeVertexBuffer () const = 0;
+	};
+
+	class VertexBufferPush
+	{
+	    public:
+
+		VertexBufferPush (VertexBufferStack &vbStack,
+				  const GLVertexBufferPtr &vertexBuffer);
+		~VertexBufferPush ();
+
+	    private:
+
+		VertexBufferStack &mVBStack;
+		const GLVertexBufferPtr &mVertexBuffer;
+	};
+    }
+}
+
+#endif
 
=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2012-09-06 09:55:05 +0000
+++ plugins/opengl/src/paint.cpp	2012-09-09 16:26:19 +0000
@@ -36,13 +36,14 @@
 #define foreach BOOST_FOREACH
 
 #include <opengl/opengl.h>
+#include <opengl/vertexbufferstack.h>
 
 #include "privates.h"
 #include "fsregion/fsregion.h"
 
 #define DEG2RAD (M_PI / 180.0f)
 
-using namespace compiz::opengl;
+namespace cgl = compiz::opengl;
 
 GLScreenPaintAttrib defaultScreenPaintAttrib = {
     0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -DEFAULT_Z_CAMERA
@@ -275,7 +276,7 @@
 
     if (!(mask & PAINT_SCREEN_NO_OCCLUSION_DETECTION_MASK))
     {
-	FullscreenRegion fs (*output);
+	cgl::FullscreenRegion fs (*output);
 
 	/* detect occlusions */
 	for (rit = pl.rbegin (); rit != pl.rend (); ++rit)
@@ -339,11 +340,11 @@
 		    tmpRegion -= w->region ();
 	    }
 
-	    FullscreenRegion::WinFlags flags = 0;
+	    cgl::FullscreenRegion::WinFlags flags = 0;
 	    if (w->type () & CompWindowTypeDesktopMask)
-	        flags |= FullscreenRegion::Desktop;
+		flags |= cgl::FullscreenRegion::Desktop;
 	    if (w->alpha ())
-		flags |= FullscreenRegion::Alpha;
+		flags |= cgl::FullscreenRegion::Alpha;
 	    
 	    /*
 	     * Windows with alpha channels can partially occlude windows
@@ -895,9 +896,16 @@
 {
     WRAPABLE_HND_FUNCTN (glAddGeometry, matrix, region, clip)
 
+    boost::shared_ptr <GLVertexBuffer> activeVertexBuffer = priv->vertexBufferStack.activeVertexBuffer ().lock ();
+
     BoxRec full;
     int    nMatrix = matrix.size ();
 
+    /* Someone is modifying our internal vertex buffer */
+    if (!priv->inGLDraw &&
+	activeVertexBuffer == priv->windowVertexBuffer)
+	priv->vertexBufferDirty = true;
+
     full = clip.handle ()->extents;
     if (region.handle ()->extents.x1 > full.x1)
 	full.x1 = region.handle ()->extents.x1;
@@ -954,7 +962,7 @@
 
 		if (nClip == 1)
 		{
-		    addQuads (priv->vertexBuffer, matrix, nMatrix,
+		    addQuads (activeVertexBuffer.get (), matrix, nMatrix,
 			      x1, y1, x2, y2,
 			      rect,
 			      maxGridWidth, maxGridHeight);
@@ -980,7 +988,7 @@
 
 			if (cbox.x1 < cbox.x2 && cbox.y1 < cbox.y2)
 			{
-			    addQuads (priv->vertexBuffer, matrix, nMatrix,
+			    addQuads (activeVertexBuffer.get (), matrix, nMatrix,
 				      cbox.x1, cbox.y1, cbox.x2, cbox.y2,
 				      rect,
 				      maxGridWidth, maxGridHeight);
@@ -1222,14 +1230,14 @@
     texture->enable (filter);
 
     #ifdef USE_GLES
-    priv->vertexBuffer->render (transform, attrib);
+    priv->vertexBufferStack.activeVertexBuffer ().lock ()->render (transform, attrib);
     #else
 
     if (!GLVertexBuffer::enabled ())
 	enableLegacyOBSAndRender (priv->gScreen, this, texture, transform,
 						 attrib, filter, mask);
     else
-	priv->vertexBuffer->render (transform, attrib);
+	priv->vertexBufferStack.activeVertexBuffer ().lock ()->render (transform, attrib);
     #endif
 
     priv->shaders.clear ();
@@ -1248,9 +1256,22 @@
     WRAPABLE_HND_FUNCTN_RETURN (bool, glDraw, transform,
 			      attrib, region, mask)
 
+    const bool transformedWindow = mask & (PAINT_WINDOW_WITH_OFFSET_MASK |
+					   PAINT_WINDOW_TRANSFORMED_MASK);
+    const bool damageRegionChanged = priv->lastDamageRegion != region;
+    const bool internalMatricesChanged = priv->updateState & (PrivateGLWindow::UpdateMatrix |
+							      PrivateGLWindow::UpdateRegion);
+    const bool readdGeometry = priv->vertexBufferDirty ||
+			       transformedWindow ||
+			       internalMatricesChanged ||
+			       damageRegionChanged;
+
     const CompRegion &reg = (mask & PAINT_WINDOW_TRANSFORMED_MASK) ?
                             infiniteRegion : region;
 
+    if (readdGeometry)
+	priv->lastDamageRegion = region;
+
     if (reg.isEmpty ())
 	return true;
 
@@ -1282,10 +1303,23 @@
 
     for (unsigned int i = 0; i < priv->textures.size (); i++)
     {
-	ml[0] = priv->matrices[i];
-	priv->vertexBuffer->begin ();
-	glAddGeometry (ml, priv->regions[i], reg);
-	if (priv->vertexBuffer->end ())
+	cgl::VertexBufferStack &vbStack (priv->vertexBufferStack);
+	cgl::VertexBufferPush push (vbStack,
+				    priv->windowVertexBuffer);
+	cgl::GLVertexBufferPtr activeVertexBuffer = vbStack.activeVertexBuffer ().lock ();
+
+	if (readdGeometry || true)
+	{
+	    priv->inGLDraw = true;
+	    ml[0] = priv->matrices[i];
+	    activeVertexBuffer->begin ();
+	    glAddGeometry (ml, priv->regions[i], reg);
+	    activeVertexBuffer->end ();
+	    priv->inGLDraw = false;
+	    priv->vertexBufferDirty = false;
+	}
+
+	if (activeVertexBuffer->countVertices ())
 	    glDrawTexture (priv->textures[i], transform, attrib, mask);
     }
 
 
=== modified file 'plugins/opengl/src/privates.h'
--- plugins/opengl/src/privates.h	2012-07-30 07:10:52 +0000
+++ plugins/opengl/src/privates.h	2012-09-09 16:26:19 +0000
@@ -28,6 +28,9 @@
 #ifndef _OPENGL_PRIVATES_H
 #define _OPENGL_PRIVATES_H
 
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 #include <core/atoms.h>
@@ -40,6 +43,7 @@
 
 #include "privatetexture.h"
 #include "privatevertexbuffer.h"
+#include "vertexbufferstack-internal.h"
 #include "opengl_options.h"
 
 extern CompOutput *targetOutput;
@@ -213,7 +217,8 @@
 
 class PrivateGLWindow :
     public WindowInterface,
-    public CompositeWindowInterface
+    public CompositeWindowInterface,
+    public compiz::opengl::VertexBufferStack
 {
     public:
 
@@ -246,6 +251,9 @@
 	bool		      needsRebind;
 
 	CompRegion    clip;
+	CompRegion    lastDamageRegion;
+	bool	      vertexBufferDirty;
+	bool	      inGLDraw;
 
 	bool	      bindFailed;
 	bool	      overlayWindow;
@@ -259,7 +267,8 @@
 
 	unsigned int lastMask;
 
-	GLVertexBuffer *vertexBuffer;
+	compiz::opengl::impl::VertexBufferStack vertexBufferStack;
+	compiz::opengl::GLVertexBufferPtr       windowVertexBuffer;
 
 	// map of shaders, plugin name is key, pair of vertex and fragment
 	// shader source code is value
@@ -267,6 +276,15 @@
 	GLVertexBuffer::AutoProgram *autoProgram;
 
 	std::list<GLIcon> icons;
+
+    private:
+
+	/* Implementation of compiz::opengl::VertexBufferStack */
+	void pushVertexBuffer (const compiz::opengl::GLVertexBufferPtr &);
+	void popVertexBufferFromTop ();
+	bool removeVertexBuffer (const compiz::opengl::GLVertexBufferPtr &);
+	bool removeLastVertexBuffer (const compiz::opengl::GLVertexBufferPtr &);
+	const compiz::opengl::GLVertexBufferWeak & activeVertexBuffer () const;
 };
 
 #endif
 
=== added directory 'plugins/opengl/src/vertexbufferstack'
=== added file 'plugins/opengl/src/vertexbufferstack/CMakeLists.txt'
--- plugins/opengl/src/vertexbufferstack/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vertexbufferstack/CMakeLists.txt	2012-09-09 16:26:19 +0000
@@ -0,0 +1,25 @@
+INCLUDE_DIRECTORIES (
+  ${COMPIZ_OPENGL_SOURCE_DIR}
+  ${COMPIZ_OPENGL_INCLUDE_DIR}
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/src
+    
+  ${Boost_INCLUDE_DIRS}
+)
+
+LINK_DIRECTORIES (${COMPIZ_LIBRARY_DIRS}) 
+
+SET( 
+  SRCS 
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/vertex-buffer-stack.cpp
+)
+
+ADD_LIBRARY( 
+  compiz_opengl_vertex_buffer_stack STATIC
+  
+  ${SRCS}
+)
+
+if (COMPIZ_BUILD_TESTING)
+ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/tests )
+endif (COMPIZ_BUILD_TESTING)
 
=== added directory 'plugins/opengl/src/vertexbufferstack/include'
=== added file 'plugins/opengl/src/vertexbufferstack/include/vertexbufferstack-internal.h'
--- plugins/opengl/src/vertexbufferstack/include/vertexbufferstack-internal.h	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vertexbufferstack/include/vertexbufferstack-internal.h	2012-09-09 16:26:19 +0000
@@ -0,0 +1,67 @@
+/*
+ * Compiz opengl plugin, VertexBufferStack interface
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * Author: Sam Spilsbury <[e-mail]>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef __COMPIZ_OPENGL_VERTEXBUFFERSTACKINTERNAL_H
+#define __COMPIZ_OPENGL_VERTEXBUFFERSTACKINTERNAL_H
+
+#include <opengl/vertexbufferstack.h>
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    namespace cgl = compiz::opengl;
+
+	    class PrivateVertexBufferStack;
+
+	    class VertexBufferStack :
+		public cgl::VertexBufferStack
+	    {
+		public:
+
+		    VertexBufferStack ();
+		    ~VertexBufferStack ();
+
+		    void pushVertexBuffer (const GLVertexBufferPtr &);
+		    bool removeLastVertexBuffer (const GLVertexBufferPtr &);
+		    bool removeVertexBuffer (const GLVertexBufferPtr &);
+		    void popVertexBufferFromTop ();
+		    const GLVertexBufferWeak & activeVertexBuffer () const;
+
+		private:
+
+		    PrivateVertexBufferStack *priv;
+	    };
+	}
+    }
+}
+
+bool operator== (const compiz::opengl::GLVertexBufferWeak &lhs,
+		 const compiz::opengl::GLVertexBufferWeak &rhs);
+bool operator!= (const compiz::opengl::GLVertexBufferWeak &lhs,
+		 const compiz::opengl::GLVertexBufferWeak &rhs);
+
+#endif
 
=== added directory 'plugins/opengl/src/vertexbufferstack/src'
=== added file 'plugins/opengl/src/vertexbufferstack/src/vertex-buffer-stack.cpp'
--- plugins/opengl/src/vertexbufferstack/src/vertex-buffer-stack.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vertexbufferstack/src/vertex-buffer-stack.cpp	2012-09-09 16:26:19 +0000
@@ -0,0 +1,145 @@
+/*
+ * Compiz, opengl plugin, VertexBufferStack class
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * Authors: Sam Spilsbury <[e-mail]>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <algorithm>
+#include <vector>
+#include "vertexbufferstack-internal.h"
+
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+class GLVertexBuffer;
+
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace impl
+	{
+	    class PrivateVertexBufferStack
+	    {
+		public:
+
+		    std::vector <cgl::GLVertexBufferWeak> savedVertexBuffers;
+		    cgl::GLVertexBufferWeak		  activeVertexBuffer;
+	    };
+	}
+    }
+}
+
+bool operator== (const compiz::opengl::GLVertexBufferWeak &lhs,
+		 const compiz::opengl::GLVertexBufferWeak &rhs)
+{
+    return lhs.lock () == rhs.lock ();
+}
+
+bool operator!= (const compiz::opengl::GLVertexBufferWeak &lhs,
+		 const compiz::opengl::GLVertexBufferWeak &rhs)
+{
+    return !(lhs == rhs);
+}
+
+cgli::VertexBufferStack::VertexBufferStack () :
+    priv (new PrivateVertexBufferStack)
+{
+}
+
+cgli::VertexBufferStack::~VertexBufferStack ()
+{
+    delete priv;
+}
+
+void
+cgli::VertexBufferStack::pushVertexBuffer (const cgl::GLVertexBufferPtr &vb)
+{
+    priv->savedVertexBuffers.push_back (priv->activeVertexBuffer);
+    priv->activeVertexBuffer = vb;
+}
+
+void
+cgli::VertexBufferStack::popVertexBufferFromTop ()
+{
+    if (!priv->savedVertexBuffers.empty ())
+	priv->activeVertexBuffer = priv->savedVertexBuffers.back ();
+    else
+	priv->activeVertexBuffer.reset ();
+
+    priv->savedVertexBuffers.pop_back ();
+}
+
+bool
+cgli::VertexBufferStack::removeLastVertexBuffer (const GLVertexBufferPtr &vb)
+{
+    cgl::GLVertexBufferWeak				    weak (vb);
+    std::vector <cgl::GLVertexBufferWeak>::reverse_iterator rit = priv->savedVertexBuffers.rbegin ();
+
+    if (weak == priv->activeVertexBuffer)
+    {
+	popVertexBufferFromTop ();
+	return true;
+    }
+
+    while (rit != priv->savedVertexBuffers.rend ())
+    {
+	if (*rit == weak)
+	{
+	    priv->savedVertexBuffers.erase (rit.base () - 1);
+	    return true;
+	}
+
+	++rit;
+    };
+
+    return false;
+}
+
+bool
+cgli::VertexBufferStack::removeVertexBuffer (const cgl::GLVertexBufferPtr &vb)
+{
+    bool found = false;
+
+    while (removeLastVertexBuffer (vb))
+	found = true;
+
+    return found;
+}
+
+const cgl::GLVertexBufferWeak &
+cgli::VertexBufferStack::activeVertexBuffer () const
+{
+    return priv->activeVertexBuffer;
+}
+
+cgl::VertexBufferPush::VertexBufferPush (cgl::VertexBufferStack &vbStack,
+					 const cgl::GLVertexBufferPtr &vertexBuffer) :
+    mVBStack (vbStack),
+    mVertexBuffer (vertexBuffer)
+{
+    vbStack.pushVertexBuffer (vertexBuffer);
+}
+
+cgl::VertexBufferPush::~VertexBufferPush ()
+{
+    mVBStack.removeLastVertexBuffer (mVertexBuffer);
+}
 
=== added directory 'plugins/opengl/src/vertexbufferstack/tests'
=== added file 'plugins/opengl/src/vertexbufferstack/tests/CMakeLists.txt'
--- plugins/opengl/src/vertexbufferstack/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vertexbufferstack/tests/CMakeLists.txt	2012-09-09 16:26:19 +0000
@@ -0,0 +1,24 @@
+find_library (GMOCK_LIBRARY gmock)
+find_library (GMOCK_MAIN_LIBRARY gmock_main)
+
+if (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+  message ("Google Mock and Google Test not found - cannot build tests!")
+  set (COMPIZ_BUILD_TESTING OFF)
+endif (NOT GMOCK_LIBRARY OR NOT GMOCK_MAIN_LIBRARY OR NOT GTEST_FOUND)
+
+include_directories (${GTEST_INCLUDE_DIRS})
+
+link_directories (${COMPIZ_LIBRARY_DIRS})
+
+add_executable (compiz_test_opengl_vertex_buffer_stack
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-opengl-vertex-buffer-stack.cpp)
+
+target_link_libraries (compiz_test_opengl_vertex_buffer_stack
+                       compiz_opengl_vertex_buffer_stack
+                       ${GTEST_BOTH_LIBRARIES}
+		       ${GMOCK_LIBRARY}
+		       ${GMOCK_MAIN_LIBRARY}
+		       ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+                       )
+
+compiz_discover_tests (compiz_test_opengl_vertex_buffer_stack COVERAGE compiz_opengl_vertex_buffer_stack)
 
=== added file 'plugins/opengl/src/vertexbufferstack/tests/test-opengl-vertex-buffer-stack.cpp'
--- plugins/opengl/src/vertexbufferstack/tests/test-opengl-vertex-buffer-stack.cpp	1970-01-01 00:00:00 +0000
+++ plugins/opengl/src/vertexbufferstack/tests/test-opengl-vertex-buffer-stack.cpp	2012-09-09 16:26:19 +0000
@@ -0,0 +1,256 @@
+/*
+ * Compiz, opengl plugin, VertexBufferStack class
+ *
+ * Copyright (c) 2012 Canonical Ltd.
+ * Authors: Sam Spilsbury <[e-mail]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <boost/make_shared.hpp>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "vertexbufferstack-internal.h"
+
+using ::testing::MatcherInterface;
+using ::testing::MakeMatcher;
+using ::testing::MatchResultListener;
+using ::testing::Matcher;
+
+template <class P>
+class ExpiredPtrMatcher :
+    public ::testing::MatcherInterface <const boost::weak_ptr <P> &>
+{
+    public:
+
+	bool MatchAndExplain (const boost::weak_ptr <P> &x, MatchResultListener *listener) const
+	{
+	    return x.expired ();
+	}
+
+	void DescribeTo (std::ostream *os) const
+	{
+	    *os << "is expired";
+	}
+
+	void DescribeNegationTo (std::ostream *os) const
+	{
+	    *os << "is not expired";
+	}
+};
+
+template <class P>
+inline Matcher<const boost::weak_ptr <P> &> IsExpired ()
+{
+    return MakeMatcher (new ExpiredPtrMatcher<P> ());
+}
+
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
+class OpenGLVertexBufferStackTest :
+    public ::testing::Test
+{
+    public:
+
+	cgli::VertexBufferStack vbStack;
+};
+
+/* Provide a dummy definition of GLVertexBuffer for our purposes,
+ * as we are only managing the pointer */
+class GLVertexBuffer
+{
+};
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushIsActive)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferWeak weak (vb);
+
+    vbStack.pushVertexBuffer (vb);
+    EXPECT_EQ (weak, vbStack.activeVertexBuffer ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushTwoPopFirstActive)
+{
+    cgl::GLVertexBufferPtr vbFirst (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbSecond (boost::make_shared <GLVertexBuffer> ());
+
+    cgl::GLVertexBufferWeak weakFirst (vbFirst);
+    cgl::GLVertexBufferWeak weakSecond (vbSecond);
+
+    vbStack.pushVertexBuffer (vbFirst);
+    vbStack.pushVertexBuffer (vbSecond);
+
+    EXPECT_EQ (weakSecond, vbStack.activeVertexBuffer ());
+
+    vbStack.popVertexBufferFromTop ();
+
+    EXPECT_EQ (weakFirst, vbStack.activeVertexBuffer ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushThreeRemoveSecondThirdIsActive)
+{
+    cgl::GLVertexBufferPtr vbFirst (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbSecond (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbThird (boost::make_shared <GLVertexBuffer> ());
+
+    cgl::GLVertexBufferWeak weakFirst (vbFirst);
+    cgl::GLVertexBufferWeak weakSecond (vbSecond);
+    cgl::GLVertexBufferWeak weakThird (vbThird);
+
+    vbStack.pushVertexBuffer (vbFirst);
+    vbStack.pushVertexBuffer (vbSecond);
+    vbStack.pushVertexBuffer (vbThird);
+
+    EXPECT_EQ (weakThird, vbStack.activeVertexBuffer ());
+
+    vbStack.removeVertexBuffer (vbSecond);
+
+    EXPECT_EQ (weakThird, vbStack.activeVertexBuffer ());
+
+    vbStack.popVertexBufferFromTop ();
+
+    EXPECT_EQ (weakFirst, vbStack.activeVertexBuffer ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestOneAndTwoOfTheSameRemovesLast)
+{
+    cgl::GLVertexBufferPtr vbFirst (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbSecond (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbThird (vbSecond);
+    cgl::GLVertexBufferPtr vbFourth (boost::make_shared <GLVertexBuffer> ());
+
+    cgl::GLVertexBufferWeak weakFirst (vbFirst);
+    cgl::GLVertexBufferWeak weakSecond (vbSecond);
+    cgl::GLVertexBufferWeak weakThird (vbThird);
+    cgl::GLVertexBufferWeak weakFourth (vbFourth);
+
+    vbStack.pushVertexBuffer (vbFirst);
+    vbStack.pushVertexBuffer (vbSecond);
+    vbStack.pushVertexBuffer (vbThird);
+    vbStack.pushVertexBuffer (vbFourth);
+
+    EXPECT_EQ (weakFourth, vbStack.activeVertexBuffer ());
+
+    vbStack.removeLastVertexBuffer (vbThird);
+
+    EXPECT_EQ (weakFourth, vbStack.activeVertexBuffer ());
+
+    vbStack.popVertexBufferFromTop ();
+
+    EXPECT_EQ (weakSecond, vbStack.activeVertexBuffer ());
+
+    vbStack.popVertexBufferFromTop ();
+
+    EXPECT_EQ (weakFirst, vbStack.activeVertexBuffer ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushTwoRemoveLastFirstIsActive)
+{
+    cgl::GLVertexBufferPtr vbFirst (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbSecond (boost::make_shared <GLVertexBuffer> ());
+
+    cgl::GLVertexBufferWeak weakFirst (vbFirst);
+    cgl::GLVertexBufferWeak weakSecond (vbSecond);
+
+    vbStack.pushVertexBuffer (vbFirst);
+    vbStack.pushVertexBuffer (vbSecond);
+
+    EXPECT_EQ (weakSecond, vbStack.activeVertexBuffer ());
+
+    vbStack.removeVertexBuffer (vbSecond);
+
+    EXPECT_EQ (weakFirst, vbStack.activeVertexBuffer ());
+
+    vbStack.popVertexBufferFromTop ();
+
+    EXPECT_THAT (vbStack.activeVertexBuffer (), IsExpired <GLVertexBuffer> ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushAndRemoveNoneActive)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferWeak weak (vb);
+
+    vbStack.pushVertexBuffer (vb);
+    EXPECT_EQ (weak, vbStack.activeVertexBuffer ());
+    vbStack.removeVertexBuffer (vb);
+    EXPECT_THAT (vbStack.activeVertexBuffer (), IsExpired <GLVertexBuffer> ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushAndRemoveBothTheSameNoneActive)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbIdentical (vb);
+    cgl::GLVertexBufferWeak weak (vb);
+    cgl::GLVertexBufferWeak weakIdentical (weak);
+
+    vbStack.pushVertexBuffer (vb);
+    vbStack.pushVertexBuffer (vbIdentical);
+    EXPECT_EQ (weak, vbStack.activeVertexBuffer ());
+    vbStack.removeVertexBuffer (vb);
+    EXPECT_THAT (vbStack.activeVertexBuffer (), IsExpired <GLVertexBuffer> ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestPushAndRemoveNonPushedDoesNothing)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferWeak weak (vb);
+    cgl::GLVertexBufferPtr  nonExistant;
+
+    vbStack.pushVertexBuffer (vb);
+    EXPECT_EQ (weak, vbStack.activeVertexBuffer ());
+    vbStack.removeVertexBuffer (nonExistant);
+    EXPECT_EQ (weak, vbStack.activeVertexBuffer ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestVertexBufferPushObject)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferWeak weak (vb);
+
+    {
+	cgl::VertexBufferPush pushedVertexBuffer (vbStack, vb);
+
+	EXPECT_EQ (vbStack.activeVertexBuffer (), weak);
+    }
+
+    EXPECT_THAT (vbStack.activeVertexBuffer (), IsExpired <GLVertexBuffer> ());
+}
+
+TEST_F (OpenGLVertexBufferStackTest, TestVertexBufferPushTwoIdenticalObjectOnlyRemovesOneEach)
+{
+    cgl::GLVertexBufferPtr vb (boost::make_shared <GLVertexBuffer> ());
+    cgl::GLVertexBufferPtr vbIdentical (vb);
+    cgl::GLVertexBufferWeak weak (vb);
+
+    {
+	cgl::VertexBufferPush pushedVertexBuffer (vbStack, vb);
+
+	{
+	    cgl::VertexBufferPush pushedVertexBuffer (vbStack, vbIdentical);
+
+	    EXPECT_EQ (vbStack.activeVertexBuffer (), weak);
+	}
+
+	EXPECT_EQ (vbStack.activeVertexBuffer (), weak);
+    }
+
+    EXPECT_THAT (vbStack.activeVertexBuffer (), IsExpired <GLVertexBuffer> ());
+}
 
=== modified file 'plugins/opengl/src/window.cpp'
--- plugins/opengl/src/window.cpp	2012-08-14 06:33:22 +0000
+++ plugins/opengl/src/window.cpp	2012-09-09 16:26:19 +0000
@@ -24,9 +24,12 @@
  * Authors: Dennis Kasprzyk <[e-mail]>
  *          David Reveman <[e-mail]>
  */
-
+#include <boost/make_shared.hpp>
 #include "privates.h"
 
+namespace cgl = compiz::opengl;
+namespace cgli = compiz::opengl::impl;
+
 GLWindow::GLWindow (CompWindow *w) :
     PluginClassHandler<GLWindow, CompWindow, COMPIZ_OPENGL_ABI> (w),
     priv (new PrivateGLWindow (w, this))
@@ -68,6 +71,36 @@
 
 };
 
+const cgl::GLVertexBufferWeak &
+PrivateGLWindow::activeVertexBuffer () const
+{
+    return vertexBufferStack.activeVertexBuffer ();
+}
+
+void
+PrivateGLWindow::pushVertexBuffer (const cgl::GLVertexBufferPtr &vertexBuffer)
+{
+    vertexBufferStack.pushVertexBuffer (vertexBuffer);
+}
+
+void
+PrivateGLWindow::popVertexBufferFromTop ()
+{
+    vertexBufferStack.popVertexBufferFromTop ();
+}
+
+bool
+PrivateGLWindow::removeVertexBuffer (const cgl::GLVertexBufferPtr &vertexBuffer)
+{
+    return vertexBufferStack.removeVertexBuffer (vertexBuffer);
+}
+
+bool
+PrivateGLWindow::removeLastVertexBuffer (const cgl::GLVertexBufferPtr &vertexBuffer)
+{
+    return vertexBufferStack.removeLastVertexBuffer (vertexBuffer);
+}
+
 PrivateGLWindow::PrivateGLWindow (CompWindow *w,
 				  GLWindow   *gw) :
     window (w),
@@ -79,11 +112,21 @@
     updateState (UpdateRegion | UpdateMatrix),
     needsRebind (true),
     clip (),
+    lastDamageRegion (),
+    vertexBufferDirty (false),
+    inGLDraw (false),
     bindFailed (false),
-    vertexBuffer (new GLVertexBuffer ()),
-    autoProgram(new GLWindowAutoProgram(this)),
+    /* We are using GL_DYNAMIC_DRAW here as the vertex buffer contents
+     * will change across different regions of the screen being damaged,
+     * however if the same region of the screen is being damaged (video)
+     * this will yeild the best performance in that case */
+    windowVertexBuffer (new GLVertexBuffer (GL::DYNAMIC_DRAW)),
+    autoProgram (new GLWindowAutoProgram(this)),
     icons ()
 {
+    windowVertexBuffer->setAutoProgram (autoProgram);
+    vertexBufferStack.pushVertexBuffer (windowVertexBuffer);
+
     paint.xScale	= 1.0f;
     paint.yScale	= 1.0f;
     paint.xTranslate	= 0.0f;
@@ -92,14 +135,11 @@
     WindowInterface::setHandler (w);
     CompositeWindowInterface::setHandler (cWindow);
 
-    vertexBuffer->setAutoProgram(autoProgram);
-
     cWindow->setNewPixmapReadyCallback (boost::bind (&PrivateGLWindow::clearTextures, this));
 }
 
 PrivateGLWindow::~PrivateGLWindow ()
 {
-    delete vertexBuffer;
     delete autoProgram;
     cWindow->setNewPixmapReadyCallback (boost::function <void ()> ());
 }
@@ -128,6 +168,18 @@
     textures.clear ();
 }
 
+compiz::opengl::VertexBufferStack &
+GLWindow::vertexBufferStack ()
+{
+    return *priv;
+}
+
+compiz::gl::AutoProgram *
+GLWindow::autoProgram ()
+{
+    return priv->autoProgram;
+}
+
 bool
 GLWindow::bind ()
 {
@@ -287,7 +339,7 @@
 GLVertexBuffer *
 GLWindow::vertexBuffer ()
 {
-    return priv->vertexBuffer;
+    return priv->vertexBufferStack.activeVertexBuffer ().lock ().get ();
 }
 
 const GLTexture::List &