Merge lp:~smspillaz/compiz/compiz.animationaddon-returns into lp:compiz/0.9.12

[Sam Spilsbury]

animationaddon: Port the animationaddon plugin to use modern GL API.

This involved a lot of changes:
 - Removal of glPush/glPop. State is assumed to be off in newer versions
   of compiz, so switch off whatever gets switched on.
 - Switch from glVertexPointer/glDrawArrays/glDrawElements to GLVertexBuffer
 - Changes in primitive assembly: GL_POLYGON doesn't exist in GLES
   so switch to using GL_TRIANGLES. This meant that the indices
   for all the animatons needed to be re-tesselated. That was done
   by hand using a winding rule which just duplicates the first and
   third vertex around the fourth.
 - Dropping of glTexEnv calls.
 - Reworking of the depth test, since writes to the depth buffer
   have been disabled by default.

animationaddon: Port the animationaddon plugin to use modern GL API.

This involved a lot of changes:
 - Removal of glPush/glPop. State is assumed to be off in newer versions
   of compiz, so switch off whatever gets switched on.
 - Switch from glVertexPointer/glDrawArrays/glDrawElements to GLVertexBuffer
 - Changes in primitive assembly: GL_POLYGON doesn't exist in GLES
   so switch to using GL_TRIANGLES. This meant that the indices
   for all the animatons needed to be re-tesselated. That was done
   by hand using a winding rule which just duplicates the first and
   third vertex around the fourth.
 - Dropping of glTexEnv calls.
 - Reworking of the depth test, since writes to the depth buffer
   have been disabled by default.

Some things still don't work:
 - Anything depending on clipping planes: glClipPlane and friends
   were removed on GLES20 and they are quite difficult to implement
   using other methods.
 - Drawing of decoration textures - these appear to be stretched
   and skewed incorrectly.
 - Lighting. This will require special shaders.

[Eleni Maria Stea (hikiko)]

good work! but you missed an else in one of your render functions (see comment in the code), you either use glDrawArrays or glDrawElements.

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Thanks for the review and for the catch!

[Sam Spilsbury (smspillaz)]

Do you have any ideas as to how we could re-implement clipping planes? I remember when I did it for the expo plugin we had to resort to using the stencil buffer which feels like overkill.

[Eleni Maria Stea (hikiko)]

I believe you mean clipping that is gles2 compatible. I needed that for the 3d windows but never had the time to implement it properly. Here's the shader you can use (look at the 3d.cpp) It's tested and it works well:

http://bazaar.launchpad.net/~hikiko/compiz/compiz.fixed-3d-windows-in-gles2/revision/3984#plugins/opengl/src/paint.cpp

How it works:
The trick is done in the pixel shader. You first calculate which pixels would be clipped if you could support clipping and then you discard them in the pixel shader.

The reason I never merged that change was that compiz shader class needed some additions before it works. https://bugs.launchpad.net/ubuntu/+source/compiz/+bug/1024208/comments/14 (I can't remember what was the main problem though because a year has passed... sorry! I'll look at it if you want)

It will be great if you have the time to get a look at it and make compiz use the shader because many plugins will work in ES2! (+thanks a lot!!! :D)

[Eleni Maria Stea (hikiko)]

+1 for the change

review: Approve

[Sam Spilsbury (smspillaz)]

Interesting. That's the other solution that I've seen posted in various places online. I guess if you have to discard individual fragments then its going to be just as expensive or more expensive than using the stencil buffer (though I suppose using the stencil buffer means that the pipeline is blocked on the stencil buffer update).

[Marco Trevisan (Treviño) (3v1n0)]

Ah, even for this please, include animationaddons in debian/compiz-plugins.install now that is built by default

[Eleni Maria Stea (hikiko)]

The stencil buffer is used for 2d clipping, to achieve a visual result similar to the glScissors. We usually use it when we need to clip more complex 2d shapes than those that Scissors can clip.

The shaders above perform clipping in 3d space (to clip some garbage around the rotating 3d cube for example).

I don't know if the pipeline is blocked during the update, to be honest. The redbook says that "clearing the buffer is one of the most expensive operations", though.

So, the decision depends on the visual result you want to achieve: you need 2d or 3d clipping? are your shapes so complex that you really need to make use of the stencil buffer?

Also, note that the 3d clipping in the shaders above might be a bit slow in some opengl implementations (but it's fine for most cases).

[Sam Spilsbury (smspillaz)]

> The stencil buffer is used for 2d clipping, to achieve a visual result similar
> to the glScissors. We usually use it when we need to clip more complex 2d
> shapes than those that Scissors can clip.
>
> The shaders above perform clipping in 3d space (to clip some garbage around
> the rotating 3d cube for example).
>
> I don't know if the pipeline is blocked during the update, to be honest. The
> redbook says that "clearing the buffer is one of the most expensive
> operations", though.
>
> So, the decision depends on the visual result you want to achieve: you need 2d
> or 3d clipping? are your shapes so complex that you really need to make use of
> the stencil buffer?

For the expo plugin we were able to get away with 2D clipping. I imagine that for the 3D windows plugin you needed 3D clipping for instance.

I'm actually not sure why animationaddon used clip planes. I suspect clip planes may have fixed the issues I was seeing with decorations being rendered incorrectly during polygon animations.

>
> Also, note that the 3d clipping in the shaders above might be a bit slow in
> some opengl implementations (but it's fine for most cases).

Indeed - I remember that was my main concern as I looked into doing something similar for expo - it was going to be an additional fragment shader pass with a loop and if statements (quite slow at the time!)

[Sam Spilsbury (smspillaz)]

> Ah, even for this please, include animationaddons in debian/compiz-
> plugins.install now that is built by default

Done - (though there's going to be "conflicts, conflicts everywhere" after three plugins starting with animation* are merged in ;-))

[Eleni Maria Stea (hikiko)]

sorry, I think top approved the branch before the 4024 change...

[Marco Trevisan (Treviño) (3v1n0)]

Ouch, some problems when building the debian package.

Please apply this: http://pastebin.com/0yKGwL67

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

Ah, thanks - I'll apply it ASAP.

Are the CI bots for merge requests disabled at the moment?

[Marco Trevisan (Treviño) (3v1n0)]

Yeah, CI has to be reimplemented in a different way, but I'm not sure this will happen for the unity7 stack, since we've to prioritize the new one.

[Marco Trevisan (Treviño) (3v1n0)]

Better, but we still fail in armhf as this doesn't build there for missing dependency.

Can you please get rid of the lines in debian/compiz-plugins.install.armhf (and define a new compiz-dev.install.armhf without the compiz-animationaddon.pc file)?

Sorry for the hassle, but... You know :)

See https://launchpadlibrarian.net/262557615/buildlog_ubuntu-yakkety-armhf.compiz_1%3A0.9.12.2+16.10.20160531-0ubuntu1_BUILDING.txt.gz

[Sam Spilsbury (smspillaz)]

Heh, no worries.

This should work fine on GLES, though as it turns out gluProject isn't available there. I've re-implemented the same thing in matrix.h and removed the dependency, so it should compile fine this time.

[lp:~smspillaz/compiz/compiz.animationaddon-returns]

4026. By Sam Spilsbury <email address hidden> on 2016-06-01

Merge lp:~smspillaz/compiz/compiz.animationaddon-returns

4027. By Sam Spilsbury <email address hidden> on 2016-06-01

animationaddon: Completely remove clip planes

(Until a different solution can be found)

4028. By Sam Spilsbury <email address hidden> on 2016-06-04

animationaddon: Don't use glClearDepth on GLES (use glClearDepthf)

[Sam Spilsbury (smspillaz)]

Marco - I've added a new commit and done a local build-test with BUILD_GLES. Hopefully this should pass ci-train now. Sorry about that hassle!

[Marco Trevisan (Treviño) (3v1n0)]

Not sure why this includes 'plugins/animationjc/compiz-animationjc.pc.in' too, so it fails building becaus it's not in compiz-dev thing. I guess you've merged this with animationjc branch, and that's broken too.

[Marco Trevisan (Treviño) (3v1n0)]

Hey, can you check these set of branches again? I'd like them to be merged...

I can do that if you're busy.

[Sam Spilsbury (smspillaz)]

Yeah I was going to have a look at them yesterday and ran out of time.

I'll take a look today. Sorry about the breakage!

Sam.
On 21 Jun 2016 02:40, "Marco Trevisan (Treviño)" <[e-mail]> wrote:

> Hey, can you check these set of branches again? I'd like them to be
> merged...
>
> I can do that if you're busy.
> --
>
> https://code.launchpad.net/~smspillaz/compiz/compiz.animationaddon-returns/+merge/295497
> You are the owner of lp:~smspillaz/compiz/compiz.animationaddon-returns.
>

[lp:~smspillaz/compiz/compiz.animationaddon-returns]

4029. By Sam Spilsbury <email address hidden> on 2016-06-22

Merge lp:compiz

4030. By Sam Spilsbury <email address hidden> on 2016-06-22

Revert addition of animationjc

[Sam Spilsbury (smspillaz)]

That should fix the issue

[Marco Trevisan (Treviño) (3v1n0)]

review: Approve

[Sam Spilsbury (smspillaz)]

Yay! I guess I need to update the .install files for the other branches too?

On Tue, Jun 28, 2016 at 9:34 AM, Marco Trevisan (Treviño)
<[e-mail]> wrote:
> The proposal to merge lp:~smspillaz/compiz/compiz.animationaddon-returns into lp:compiz has been updated.
>
> Status: Needs review => Approved
>
> For more details, see:
> https://code.launchpad.net/~smspillaz/compiz/compiz.animationaddon-returns/+merge/295497
> --
> You are the owner of lp:~smspillaz/compiz/compiz.animationaddon-returns.

--
Sam Spilsbury

=== modified file 'debian/compiz-dev.install'
--- debian/compiz-dev.install	2014-11-24 22:25:07 +0000
+++ debian/compiz-dev.install	2016-06-22 01:26:00 +0000
@@ -1,6 +1,7 @@
 debian/tmp/usr/include/compiz/[!d]*
 debian/tmp/usr/lib/*/libcompiz_core.so
 debian/tmp/usr/lib/*/pkgconfig/compiz-animation.pc
+debian/tmp/usr/lib/*/pkgconfig/compiz-animationaddon.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-compiztoolbox.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-composite.pc
 debian/tmp/usr/lib/*/pkgconfig/compiz-cube.pc

=== modified file 'debian/compiz-plugins.install'
--- debian/compiz-plugins.install	2016-05-13 09:45:31 +0000
+++ debian/compiz-plugins.install	2016-06-22 01:26:00 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationaddon.*
+usr/share/compiz/*animationaddon.*
 usr/lib/*/compiz/*bench.*
 usr/share/compiz/*bench.*
 usr/lib/*/compiz/*blur.*

=== modified file 'debian/compiz-plugins.install.armel'
--- debian/compiz-plugins.install.armel	2014-12-02 14:42:34 +0000
+++ debian/compiz-plugins.install.armel	2016-06-22 01:26:00 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationaddon.*
+usr/share/compiz/*animationaddon.*
 usr/lib/*/compiz/*clone.*
 usr/share/compiz/*clone.*
 usr/lib/*/compiz/*crashhandler.*

=== modified file 'debian/compiz-plugins.install.armhf'
--- debian/compiz-plugins.install.armhf	2014-12-02 14:42:34 +0000
+++ debian/compiz-plugins.install.armhf	2016-06-22 01:26:00 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationaddon.*
+usr/share/compiz/*animationaddon.*
 usr/lib/*/compiz/*clone.*
 usr/share/compiz/*clone.*
 usr/lib/*/compiz/*crashhandler.*

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2016-05-13 06:42:58 +0000
+++ plugins/CMakeLists.txt	2016-06-22 01:26:00 +0000
@@ -10,7 +10,6 @@
 include_directories (${COMPIZ_INTERNAL_INCLUDES})
 
 # temporarily disable plugins that aren't ported yet
-set (COMPIZ_DISABLE_PLUGIN_ANIMATIONADDON ON)
 set (COMPIZ_DISABLE_PLUGIN_BICUBIC ON)
 set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)
 set (COMPIZ_DISABLE_PLUGIN_GROUP ON)

=== modified file 'plugins/animation/include/animation/animeffect.h'
--- plugins/animation/include/animation/animeffect.h	2015-03-01 21:55:10 +0000
+++ plugins/animation/include/animation/animeffect.h	2016-06-22 01:26:00 +0000
@@ -142,7 +142,7 @@
     virtual void updateAttrib (GLWindowPaintAttrib &) {}
     virtual void updateTransform (GLMatrix &) {}
     virtual void prePaintWindow () {}
-    virtual void postPaintWindow () {}
+    virtual void postPaintWindow (const GLMatrix &) {}
     virtual bool postPaintWindowUsed () { return false; }
 
     /// Returns true if the animation is still in progress.
@@ -174,7 +174,10 @@
 			    const CompRegion            &clip,
 			    unsigned int                maxGridWidth,
 			    unsigned int                maxGridHeight);
-    virtual void drawGeometry ();
+    virtual void drawGeometry (GLTexture                 *texture,
+			       const GLMatrix            &transform,
+			       const GLWindowPaintAttrib &attrib,
+			       unsigned int              mask);
 
     virtual bool paintWindowUsed () { return false; }
     virtual bool paintWindow (GLWindow			*gWindow,

=== modified file 'plugins/animation/include/animation/grid.h'
--- plugins/animation/include/animation/grid.h	2012-08-14 06:33:22 +0000
+++ plugins/animation/include/animation/grid.h	2016-06-22 01:26:00 +0000
@@ -101,6 +101,5 @@
 		      const CompRegion            &clip,
 		      unsigned int                maxGridWidth,
 		      unsigned int                maxGridHeight);
-    void drawGeometry ();
 };
 #endif

=== modified file 'plugins/animation/include/animation/multi.h'
--- plugins/animation/include/animation/multi.h	2013-04-25 11:07:54 +0000
+++ plugins/animation/include/animation/multi.h	2016-06-22 01:26:00 +0000
@@ -1,6 +1,8 @@
 #ifndef ANIMATION_MULTI_H
 #define ANIMATION_MULTI_H
 #include "animation.h"
+#include <opengl/opengl.h>
+#include <composite/composite.h>
 /// Special class, allows multiple copies of an animation to happen
 /// at any one time. Create your "single copy" animation class first
 /// and then create a new animation which derives from this template
@@ -140,9 +142,8 @@
 	    foreach (SingleAnim *a, animList)
 	    {
 		setCurrAnimNumber (mAWindow, count);
-		GLWindowPaintAttrib attr (attrib);
-		a->updateAttrib (attr);
-		mGlPaintAttribs.at (count) = attr;
+		mGlPaintAttribs[count] = attrib;
+		a->updateAttrib (mGlPaintAttribs[count]);
 		++count;
 	    }
 	}
@@ -172,14 +173,14 @@
 	    }
 	}
 
-	void postPaintWindow ()
+	void postPaintWindow (const GLMatrix &transform)
 	{
 	    int count = 0;
 	    foreach (SingleAnim *a, animList)
 	    {
 		setCurrAnimNumber (mAWindow, count);
 		++count;
-		a->postPaintWindow ();
+		a->postPaintWindow (transform);
 	    }
 	}
 
@@ -377,11 +378,20 @@
 		++count;
 
 		if (animList.at (currentAnim)->paintWindowUsed ())
-		    status |= animList.at (currentAnim)->paintWindow
-			    (gWindow, wAttrib, wTransform, region, mask);
+		    status |= animList.at (currentAnim)->paintWindow (gWindow,
+								      wAttrib,
+								      wTransform,
+								      region,
+								      mask);
 		else
-		    status |= gWindow->glPaint
-			    (wAttrib, wTransform, region, mask);
+		{
+		    unsigned int index = gWindow->glPaintGetCurrentIndex ();
+		    status |= gWindow->glPaint (wAttrib,
+						wTransform,
+						region,
+						mask);
+		    gWindow->glPaintSetCurrentIndex (index);
+		}
 	    }
 
 	    return status;

=== modified file 'plugins/animation/src/animation.cpp'
--- plugins/animation/src/animation.cpp	2015-03-16 18:45:33 +0000
+++ plugins/animation/src/animation.cpp	2016-06-22 01:26:00 +0000
@@ -1632,20 +1632,20 @@
     if (mCurAnimation)
 	mCurAnimation->setCurPaintAttrib (attrib);
 
-    gWindow->glDrawTexture (texture, transform, attrib, mask);
+    if (mCurAnimation)
+    {
+        if (mCurAnimation->initialized ())
+            mCurAnimation->drawGeometry (texture, transform, attrib, mask);
+    }
+    else
+        gWindow->glDrawTexture (texture, transform, attrib, mask);
 }
 
 #if 0 // Not ported yet
 void
 PrivateAnimWindow::glDrawGeometry ()
 {
-    if (mCurAnimation)
-    {
-	if (mCurAnimation->initialized ())
-	    mCurAnimation->drawGeometry ();
-    }
-    else
-	gWindow->glDrawGeometry ();
+
 }
 #endif
 
@@ -1658,11 +1658,15 @@
 }
 
 void
-Animation::drawGeometry ()
+Animation::drawGeometry (GLTexture                 *texture,
+			 const GLMatrix            &transform,
+			 const GLWindowPaintAttrib &attrib,
+			 unsigned int              mask)
 {
-#if 0 // Not ported yet
-    mAWindow->priv->gWindow->glDrawGeometry ();
-#endif
+    GLWindow::get (mAWindow->mWindow)->glDrawTexture (texture,
+						      transform,
+						      attrib,
+						      mask);
 }
 
 bool
@@ -1731,18 +1735,7 @@
 	status = gWindow->glPaint (wAttrib, wTransform, region, mask);
 
     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
-    }
+	mCurAnimation->postPaintWindow (wTransform);
 
     return status;
 }

=== modified file 'plugins/animation/src/glide.cpp'
--- plugins/animation/src/glide.cpp	2015-03-02 08:48:27 +0000
+++ plugins/animation/src/glide.cpp	2016-06-22 01:26:00 +0000
@@ -167,7 +167,7 @@
 }
 
 void
-GlideAnim::postPaintWindow ()
+GlideAnim::postPaintWindow (const GLMatrix &transform)
 {
     if (90 < glideModRotAngle &&
 	glideModRotAngle < 270)

=== modified file 'plugins/animation/src/grid.cpp'
--- plugins/animation/src/grid.cpp	2013-07-24 17:36:47 +0000
+++ plugins/animation/src/grid.cpp	2016-06-22 01:26:00 +0000
@@ -388,12 +388,6 @@
     }
 }
 
-void
-GridAnim::drawGeometry ()
-{
-    // Deprecated
-}
-
 GridTransformAnim::GridTransformAnim (CompWindow       *w,
 				      WindowEvent      curWindowEvent,
 				      float            duration,

=== modified file 'plugins/animation/src/private.h'
--- plugins/animation/src/private.h	2013-10-31 15:59:14 +0000
+++ plugins/animation/src/private.h	2016-06-22 01:26:00 +0000
@@ -588,7 +588,7 @@
 
     void prePaintWindow ();
     inline bool postPaintWindowUsed () { return true; }
-    void postPaintWindow ();
+    void postPaintWindow (const GLMatrix &);
     void adjustDuration ();
     bool zoomToIcon ();
     void applyTransform ();

=== modified file 'plugins/animationaddon/CMakeLists.txt'
--- plugins/animationaddon/CMakeLists.txt	2012-05-21 08:50:26 +0000
+++ plugins/animationaddon/CMakeLists.txt	2016-06-22 01:26:00 +0000
@@ -1,7 +1,4 @@
 find_package (Compiz REQUIRED)
 include (CompizPlugin)
-include (FindOpenGL)
 
-if (OPENGL_GLU_FOUND)
-    compiz_plugin (animationaddon PLUGINDEPS composite opengl animation LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
-endif (OPENGL_GLU_FOUND)
+compiz_plugin (animationaddon PLUGINDEPS composite opengl animation)

=== modified file 'plugins/animationaddon/include/animationaddon/animationaddon.h'
--- plugins/animationaddon/include/animationaddon/animationaddon.h	2010-01-27 16:32:40 +0000
+++ plugins/animationaddon/include/animationaddon/animationaddon.h	2016-06-22 01:26:00 +0000
@@ -97,7 +97,7 @@
 		    GLuint blendMode);
     ~ParticleSystem ();
 
-    void draw (int offsetX = 0, int offsetY = 0);
+    void draw (const GLMatrix &transform, int offsetX = 0, int offsetY = 0);
     void update (float time);
     vector<Particle> &particles () { return mParticles; }
     void activate () { mActive = true; }
@@ -120,8 +120,8 @@
 
     vector<GLfloat> mVerticesCache;
     vector<GLfloat> mCoordsCache;
-    vector<GLfloat> mColorsCache;
-    vector<GLfloat> mDColorsCache;
+    vector<GLushort> mColorsCache;
+    vector<GLushort> mDColorsCache;
 };
 
 class ParticleAnim :
@@ -135,7 +135,7 @@
 		  const AnimEffect info,
 		  const CompRect &icon);
     ~ParticleAnim () {}
-    void postPaintWindow ();
+    void postPaintWindow (const GLMatrix &);
     bool postPaintWindowUsed () { return true; }
     void updateBB (CompOutput &output);
     bool updateBBUsed () { return true; }
@@ -259,14 +259,17 @@
 
     void step ();
     void prePaintWindow ();
-    void postPaintWindow ();
+    void postPaintWindow (const GLMatrix &);
     bool postPaintWindowUsed () { return true; }
     void addGeometry (const GLTexture::MatrixList &matrix,
                       const CompRegion            &region,
                       const CompRegion            &clipRegion,
                       unsigned int                maxGridWidth,
                       unsigned int                maxGridHeight);
-    void drawGeometry ();
+    void drawGeometry (GLTexture                 *texture,
+		       const GLMatrix            &transform,
+		       const GLWindowPaintAttrib &attrib,
+		       unsigned int              mask);
     virtual void updateBB (CompOutput &output);
     bool updateBBUsed () { return true; }
     bool prePreparePaint (int msSinceLastPaint);
@@ -274,7 +277,8 @@
 
     virtual void stepPolygon (PolygonObject *p,
 			      float forwardProgress);
-    virtual void transformPolygon (const PolygonObject *p) {}
+    virtual void transformPolygon (GLMatrix &matrix,
+				   const PolygonObject *p) {}
 
     /// For effects that have decel. motion
     virtual bool deceleratingMotion () { return false; }
@@ -301,7 +305,8 @@
     void processIntersectingPolygons ();
     virtual void freePolygonObjects ();
     void freeClipsPolygons ();
-    void prepareDrawingForAttrib (GLFragment::Attrib &attrib);
+    void prepareDrawingForAttrib (GLWindowPaintAttrib &attrib,
+				  GLVertexBuffer      &vertexBuffer);
 
     int mNumDrawGeometryCalls;
     int mNumClipsPassed;	 /**< # of clips passed to animAddWindowGeometry so far
@@ -327,15 +332,16 @@
     bool mIncludeShadows;        ///< Whether to include shadows in polygon
 
 private:
-    inline void drawPolygonClipIntersection (const PolygonObject *p,
+    inline void drawPolygonClipIntersection (GLTexture *texture,
+					     const GLMatrix &transform,
+					     const PolygonObject *p,
 					     const Clip4Polygons &c,
 					     const GLfloat *vertexTexCoords,
 					     int pass,
 					     float forwardProgress,
-					     GLdouble clipPlane[4][4],
 					     const CompOutput &output,
 					     float newOpacity,
 					     bool decelerates,
-					     GLfloat skewMat[16]);
+					     GLMatrix &skewMat);
 };
 #endif

=== modified file 'plugins/animationaddon/src/airplane.cpp'
--- plugins/animationaddon/src/airplane.cpp	2013-02-27 11:33:10 +0000
+++ plugins/animationaddon/src/airplane.cpp	2016-06-22 01:26:00 +0000
@@ -271,8 +271,8 @@
 	pv[22] = topLeftY;
 	pv[23] = -halfThick;
 
-	// 16 indices for 4 sides (for quad strip)
-	p->sideIndices = (GLushort *) calloc (4 * 4, sizeof (GLushort));
+	// 24 indices for 4 sides (for triangle strip)
+	p->sideIndices = (GLushort *) calloc (6 * 4, sizeof (GLushort));
 	if (!p->sideIndices)
 	{
 	    compLogMessage ("animation", CompLogLevelError,
@@ -287,22 +287,30 @@
 	ind[id++] = 0;
 	ind[id++] = 7;
 	ind[id++] = 6;
-	ind[id++] = 1;
-
-	ind[id++] = 1;
-	ind[id++] = 6;
-	ind[id++] = 5;
-	ind[id++] = 2;
-
-	ind[id++] = 2;
-	ind[id++] = 5;
-	ind[id++] = 4;
-	ind[id++] = 3;
-
-	ind[id++] = 3;
-	ind[id++] = 4;
-	ind[id++] = 7;
-	ind[id++] = 0;
+	ind[id++] = 0;
+	ind[id++] = 1;
+	ind[id++] = 6;
+
+	ind[id++] = 1;
+	ind[id++] = 6;
+	ind[id++] = 5;
+	ind[id++] = 1;
+	ind[id++] = 2;
+	ind[id++] = 5;
+
+	ind[id++] = 2;
+	ind[id++] = 5;
+	ind[id++] = 4;
+	ind[id++] = 2;
+	ind[id++] = 3;
+	ind[id++] = 4;
+
+	ind[id++] = 3;
+	ind[id++] = 4;
+	ind[id++] = 7;
+	ind[id++] = 3;
+	ind[id++] = 0;
+	ind[id++] = 7;
 
 	if (i < 4)
 	{
@@ -318,6 +326,8 @@
 	    p->boundingBox.x2 = ceil (p->centerPos.x () + bottomRightX);
 	    p->boundingBox.y2 = ceil (p->centerPos.y () + bottomLeftY);
 	}
+
+	p->normals = NULL;
 	
 	i++;
     }
@@ -692,41 +702,42 @@
 }
 
 void
-AirplaneAnim::transformPolygon (const PolygonObject *pol)
+AirplaneAnim::transformPolygon (GLMatrix &matrix,
+				const PolygonObject *pol)
 {
     AirplanePolygonObject *p = (AirplanePolygonObject *) pol;
 
-    glRotatef (p->flyRotation.x (), 1, 0, 0);	//rotate on axis X
-    glRotatef (-p->flyRotation.y (), 0, 1, 0);	// rotate on axis Y
-    glRotatef (p->flyRotation.z (), 0, 0, 1);	// rotate on axis Z
+    matrix.rotate (p->flyRotation.x (), 1, 0, 0);	//rotate on axis X
+    matrix.rotate (-p->flyRotation.y (), 0, 1, 0);	// rotate on axis Y
+    matrix.rotate (p->flyRotation.z (), 0, 0, 1);	// rotate on axis Z
 
-    glScalef (1.0 / (1.0 + p->flyScale),
-	      1.0 / (1.0 + p->flyScale), 1.0 / (1.0 + p->flyScale));
+    matrix.scale (1.0 / (1.0 + p->flyScale),
+		  1.0 / (1.0 + p->flyScale), 1.0 / (1.0 + p->flyScale));
 
     // Move by "rotation axis offset A"
-    glTranslatef (p->rotAxisOffsetA.x (), p->rotAxisOffsetA.y (),
-		  p->rotAxisOffsetA.z ());
+    matrix.translate (p->rotAxisOffsetA.x (), p->rotAxisOffsetA.y (),
+		      p->rotAxisOffsetA.z ());
 
     // Rotate by desired angle A
-    glRotatef (p->rotAngleA, p->rotAxisA.x (), p->rotAxisA.y (),
-	       p->rotAxisA.z ());
+    matrix.rotate (p->rotAngleA, p->rotAxisA.x (), p->rotAxisA.y (),
+		   p->rotAxisA.z ());
 
     // Move back to center from  A
-    glTranslatef (-p->rotAxisOffsetA.x (), -p->rotAxisOffsetA.y (),
-		  -p->rotAxisOffsetA.z ());
+    matrix.translate (-p->rotAxisOffsetA.x (), -p->rotAxisOffsetA.y (),
+		      -p->rotAxisOffsetA.z ());
 
 
     // Move by "rotation axis offset B"
-    glTranslatef (p->rotAxisOffsetB.x (), p->rotAxisOffsetB.y (),
-		  p->rotAxisOffsetB.z ());
+    matrix.translate (p->rotAxisOffsetB.x (), p->rotAxisOffsetB.y (),
+		      p->rotAxisOffsetB.z ());
 
     // Rotate by desired angle B
-    glRotatef (p->rotAngleB, p->rotAxisB.x (), p->rotAxisB.y (),
-	       p->rotAxisB.z ());
+    matrix.rotate (p->rotAngleB, p->rotAxisB.x (), p->rotAxisB.y (),
+		   p->rotAxisB.z ());
 
     // Move back to center from B
-    glTranslatef (-p->rotAxisOffsetB.x (), -p->rotAxisOffsetB.y (),
-		  -p->rotAxisOffsetB.z ());
+    matrix.translate (-p->rotAxisOffsetB.x (), -p->rotAxisOffsetB.y (),
+		      -p->rotAxisOffsetB.z ());
 }
 
 

=== modified file 'plugins/animationaddon/src/animationaddon.cpp'
--- plugins/animationaddon/src/animationaddon.cpp	2013-05-09 13:43:07 +0000
+++ plugins/animationaddon/src/animationaddon.cpp	2016-06-22 01:26:00 +0000
@@ -81,7 +81,7 @@
 #include "private.h"
 
 class AnimAddonPluginVTable :
-    public CompPlugin::VTableForScreenAndWindow<AnimAddonScreen, AnimAddonWindow>
+    public CompPlugin::VTableForScreenAndWindow<AnimAddonScreen, AnimAddonWindow, ANIMATIONADDON_ABI>
 {
 public:
     bool init ();
@@ -232,7 +232,7 @@
 }
 
 AnimAddonWindow::AnimAddonWindow (CompWindow *w) :
-    PluginClassHandler<AnimAddonWindow, CompWindow> (w),
+    PluginClassHandler<AnimAddonWindow, CompWindow, ANIMATIONADDON_ABI> (w),
     mWindow (w),
     aWindow (AnimWindow::get (w))
 {

=== modified file 'plugins/animationaddon/src/dissolve.cpp'
--- plugins/animationaddon/src/dissolve.cpp	2010-08-23 03:24:20 +0000
+++ plugins/animationaddon/src/dissolve.cpp	2016-06-22 01:26:00 +0000
@@ -33,7 +33,7 @@
     float o = 0.2;
     float factor = (4 - layer) * o;
     
-    attrib.opacity *= o / (1.0 - factor);
+    attrib.opacity *= (o / (1.0 - factor)) * (1.0 - getDissolveSingleProgress ());
 }
 
 void
@@ -62,5 +62,14 @@
 void
 DissolveSingleAnim::updateBB (CompOutput &output)
 {
-    mAWindow->expandBBWithWindow ();
+    CompRect outRect (mAWindow->mWindow->outputRect ());
+
+    Box windowBox =
+    {
+	static_cast <short int> (outRect.x () - 4),
+	static_cast <short int> (outRect.x () + outRect.width () + 4),
+	static_cast <short int> (outRect.y () - 4),
+	static_cast <short int> (outRect.y () + outRect.height () + 4)
+    };
+    mAWindow->expandBBWithBox (windowBox);
 }

=== modified file 'plugins/animationaddon/src/particle.cpp'
--- plugins/animationaddon/src/particle.cpp	2013-02-27 11:33:10 +0000
+++ plugins/animationaddon/src/particle.cpp	2016-06-22 01:26:00 +0000
@@ -81,7 +81,7 @@
 }
 
 void
-ParticleSystem::draw (int offsetX, int offsetY)
+ParticleSystem::draw (const GLMatrix &transform, int offsetX, int offsetY)
 {
     // TODO
     // The part below should ideally be done in ParticleSystem constructor
@@ -95,9 +95,8 @@
 		 GL_RGBA, GL_UNSIGNED_BYTE, fireTex);
     glBindTexture (GL_TEXTURE_2D, 0);
 
-
-    glPushMatrix ();
-    glTranslated (offsetX - mX, offsetY - mY, 0);
+    GLMatrix translatedMatrix (transform);
+    //translatedMatrix.translate (offsetX - mX, offsetY - mY, 0);
 
     glEnable (GL_BLEND);
     if (mTex)
@@ -105,26 +104,27 @@
 	glBindTexture (GL_TEXTURE_2D, mTex);
 	glEnable (GL_TEXTURE_2D);
     }
-    mGScreen->setTexEnvMode (GL_MODULATE);
 
-    mVerticesCache.resize (4 * 3 * mParticles.size ());
-    mCoordsCache.resize (4 * 2 * mParticles.size ());
-    mColorsCache.resize (4 * 4 * mParticles.size ());
+    mVerticesCache.resize (6 * 3 * mParticles.size ());
+    mCoordsCache.resize (6 * 2 * mParticles.size ());
+    mColorsCache.resize (6 * 4 * mParticles.size ());
     if (mDarkenAmount > 0)
-	mDColorsCache.resize (4 * 4 * mParticles.size ());
+	mDColorsCache.resize (6 * 4 * mParticles.size ());
 
-    GLfloat *dcolors = &mDColorsCache[0];
+    GLushort *dcolors = &mDColorsCache[0];
     GLfloat *vertices = &mVerticesCache[0];
     GLfloat *coords = &mCoordsCache[0];
-    GLfloat *colors = &mColorsCache[0];
+    GLushort *colors = &mColorsCache[0];
 
-    int cornersSize = sizeof (GLfloat) * 8;
+    int cornersSize = sizeof (GLfloat) * 12;
     int colorSize = sizeof (GLfloat) * 4;
 
-    GLfloat cornerCoords[8] = {0.0, 0.0,
+    GLfloat cornerCoords[12] = {0.0, 0.0,
 			       0.0, 1.0,
 			       1.0, 1.0,
-			       1.0, 0.0};
+			       1.0, 1.0,
+			       1.0, 0.0,
+			       0.0, 0.0};
 
     int numActive = 0;
 
@@ -133,7 +133,7 @@
 	if (part.life <= 0.0f)	     // Ignore dead particles
 	    continue;
 
-	numActive += 4;
+	numActive += 6;
 
 	float w = part.width / 2;
 	float h = part.height / 2;
@@ -154,24 +154,34 @@
 	vertices[8] = part.z;
 
 	vertices[9] = part.x + w;
-	vertices[10] = part.y - h;
+	vertices[10] = part.y + h;
 	vertices[11] = part.z;
 
-	vertices += 12;
+	vertices[12] = part.x + w;
+	vertices[13] = part.y - h;
+	vertices[14] = part.z;
+
+	vertices[15] = part.x - w;
+	vertices[16] = part.y - h;
+	vertices[17] = part.z;
+
+	vertices += 18;
 
 	memcpy (coords, cornerCoords, cornersSize);
 
-	coords += 8;
+	coords += 12;
 
-	colors[0] = part.r;
-	colors[1] = part.g;
-	colors[2] = part.b;
-	colors[3] = part.life * part.a;
+	colors[0] = part.r * COLOR;
+	colors[1] = part.g * COLOR;
+	colors[2] = part.b * COLOR;
+	colors[3] = part.life * part.a * COLOR;
 	memcpy (colors + 4, colors, colorSize);
 	memcpy (colors + 8, colors, colorSize);
 	memcpy (colors + 12, colors, colorSize);
+	memcpy (colors + 16, colors, colorSize);
+	memcpy (colors + 20, colors, colorSize);
 
-	colors += 16;
+	colors += 24;
 
 	if (mDarkenAmount > 0)
 	{
@@ -182,34 +192,35 @@
 	    memcpy (dcolors + 4, dcolors, colorSize);
 	    memcpy (dcolors + 8, dcolors, colorSize);
 	    memcpy (dcolors + 12, dcolors, colorSize);
+	    memcpy (dcolors + 16, dcolors, colorSize);
+	    memcpy (dcolors + 20, dcolors, colorSize);
 
-	    dcolors += 16;
+	    dcolors += 24;
 	}
     }
 
-    glEnableClientState (GL_COLOR_ARRAY);
-
-    glTexCoordPointer (2, GL_FLOAT, 2 * sizeof (GLfloat), &mCoordsCache[0]);
-    glVertexPointer (3, GL_FLOAT, 3 * sizeof (GLfloat), &mVerticesCache[0]);
+    GLVertexBuffer *stream = GLVertexBuffer::streamingBuffer ();
 
     // darken the background
     if (mDarkenAmount > 0)
     {
 	glBlendFunc (GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
-	glColorPointer (4, GL_FLOAT, 4 * sizeof (GLfloat), &mDColorsCache[0]);
-	glDrawArrays (GL_QUADS, 0, numActive);
+	stream->begin (GL_TRIANGLES);
+	stream->addTexCoords (0, numActive, &mCoordsCache[0]);
+	stream->addVertices (numActive, &mVerticesCache[0]);
+	stream->addColors (numActive, &mDColorsCache[0]);
+	if (stream->end ())
+	    stream->render (translatedMatrix);
     }
     // draw particles
     glBlendFunc (GL_SRC_ALPHA, mBlendMode);
 
-    glColorPointer (4, GL_FLOAT, 4 * sizeof (GLfloat), &mColorsCache[0]);
-    glDrawArrays (GL_QUADS, 0, numActive);
-    glDisableClientState (GL_COLOR_ARRAY);
-
-    glPopMatrix ();
-    glColor4usv (defaultColor);
-
-    mGScreen->setTexEnvMode (GL_REPLACE);
+    stream->begin (GL_TRIANGLES);
+    stream->addTexCoords (0, numActive, &mCoordsCache[0]);
+    stream->addVertices (numActive, &mVerticesCache[0]);
+    stream->addColors (numActive, &mColorsCache[0]);
+    if (stream->end ())
+	stream->render (translatedMatrix);
 
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glDisable (GL_TEXTURE_2D);
@@ -217,12 +228,13 @@
 }
 
 void
-ParticleAnim::postPaintWindow ()
+ParticleAnim::postPaintWindow (const GLMatrix &transform)
 {
     foreach (ParticleSystem &ps, mParticleSystems)
 	if (ps.active ())
 	    // offset by window pos.
-	    ps.draw (mWindow->x () - mWindow->output ().left,
+	    ps.draw (transform,
+		     mWindow->x () - mWindow->output ().left,
 	             mWindow->y () - mWindow->output ().top);
 }
 

=== modified file 'plugins/animationaddon/src/polygon.cpp'
--- plugins/animationaddon/src/polygon.cpp	2013-02-27 11:33:10 +0000
+++ plugins/animationaddon/src/polygon.cpp	2016-06-22 01:26:00 +0000
@@ -34,7 +34,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-#include <GL/glu.h>
 #include "private.h"
 
 static const unsigned short MIN_WINDOW_GRID_SIZE = 10;
@@ -256,8 +255,8 @@
 	    pv[22] = -halfH;
 	    pv[23] = -halfThick;
 
-	    // 16 indices for 4 sides (for quads)
-	    p->sideIndices = (GLushort *)calloc (4 * 4, sizeof (GLushort));
+	    // 24 indices for 4 sides (for triangles)
+	    p->sideIndices = (GLushort *)calloc (6 * 4, sizeof (GLushort));
 	    if (!p->sideIndices)
 	    {
 		compLogMessage ("animationaddon", CompLogLevelError,
@@ -275,6 +274,8 @@
 	    ind[id++] = 6; // First vertex
 	    ind[id++] = 1;
 	    ind[id++] = 0;
+	    ind[id++] = 6;
+	    ind[id++] = 0;
 	    ind[id++] = 7;
 	    nor[6 * 3 + 0] = -1; // Flat shading only uses 1st vertex's normal
 	    nor[6 * 3 + 1] = 0; // in a polygon, vertex 6 for this face.
@@ -284,16 +285,20 @@
 	    ind[id++] = 1;
 	    ind[id++] = 6;
 	    ind[id++] = 5;
+	    ind[id++] = 5;
 	    ind[id++] = 2;
+	    ind[id++] = 1;
 	    nor[1 * 3 + 0] = 0;
 	    nor[1 * 3 + 1] = 1;
 	    nor[1 * 3 + 2] = 0;
 
 	    // Right face
+	    ind[id++] = 5;
 	    ind[id++] = 2;
+	    ind[id++] = 3;
 	    ind[id++] = 5;
+	    ind[id++] = 3;
 	    ind[id++] = 4;
-	    ind[id++] = 3;
 	    nor[2 * 3 + 0] = 1;
 	    nor[2 * 3 + 1] = 0;
 	    nor[2 * 3 + 2] = 0;
@@ -302,7 +307,9 @@
 	    ind[id++] = 7;
 	    ind[id++] = 0;
 	    ind[id++] = 3;
+	    ind[id++] = 3;
 	    ind[id++] = 4;
+	    ind[id++] = 7;
 	    nor[7 * 3 + 0] = 0;
 	    nor[7 * 3 + 1] = -1;
 	    nor[7 * 3 + 2] = 0;
@@ -541,8 +548,8 @@
 	    pv[34] = topY;
 	    pv[35] = -halfThick;
 
-	    // 24 indices per 6 sides (for quads)
-	    p->sideIndices = (GLushort *)calloc (4 * 6, sizeof (GLushort));
+	    // 36 indices per 6 sides (for triangles)
+	    p->sideIndices = (GLushort *)calloc (6 * 6, sizeof (GLushort));
 	    if (!p->sideIndices)
 	    {
 		compLogMessage ("animationaddon", CompLogLevelError,
@@ -562,7 +569,9 @@
 	    ind[id++] = 11; // First vertex
 	    ind[id++] = 10;
 	    ind[id++] = 1;
+	    ind[id++] = 1;
 	    ind[id++] = 0;
+	    ind[id++] = 11;
 	    nor[11 * 3 + 0] = -1; // Flat shading only uses 1st vertex's normal
 	    nor[11 * 3 + 1] = -1; // in a polygon, vertex 11 for this face.
 	    nor[11 * 3 + 2] = 0;
@@ -573,7 +582,9 @@
 	    ind[id++] = 1;
 	    ind[id++] = 10;
 	    ind[id++] = 9;
+	    ind[id++] = 9;
 	    ind[id++] = 2;
+	    ind[id++] = 1;
 	    nor[1 * 3 + 0] = -1;
 	    nor[1 * 3 + 1] = 0;
 	    nor[1 * 3 + 2] = 0;
@@ -582,7 +593,9 @@
 	    ind[id++] = 2;
 	    ind[id++] = 9;
 	    ind[id++] = 8;
+	    ind[id++] = 8;
 	    ind[id++] = 3;
+	    ind[id++] = 2;
 	    nor[2 * 3 + 0] = -1;
 	    nor[2 * 3 + 1] = 1;
 	    nor[2 * 3 + 2] = 0;
@@ -593,7 +606,9 @@
 	    ind[id++] = 3;
 	    ind[id++] = 8;
 	    ind[id++] = 7;
+	    ind[id++] = 7;
 	    ind[id++] = 4;
+	    ind[id++] = 3;
 	    nor[3 * 3 + 0] = 1;
 	    nor[3 * 3 + 1] = 1;
 	    nor[3 * 3 + 2] = 0;
@@ -604,7 +619,9 @@
 	    ind[id++] = 4;
 	    ind[id++] = 7;
 	    ind[id++] = 6;
+	    ind[id++] = 6;
 	    ind[id++] = 5;
+	    ind[id++] = 4;
 	    nor[4 * 3 + 0] = 1;
 	    nor[4 * 3 + 1] = 0;
 	    nor[4 * 3 + 2] = 0;
@@ -613,7 +630,9 @@
 	    ind[id++] = 5;
 	    ind[id++] = 6;
 	    ind[id++] = 11;
+	    ind[id++] = 11;
 	    ind[id++] = 0;
+	    ind[id++] = 5;
 	    nor[5 * 3 + 0] = 1;
 	    nor[5 * 3 + 1] = -1;
 	    nor[5 * 3 + 2] = 0;
@@ -946,8 +965,8 @@
 	    pv[22] = -shards[yc][xc].centerY + shards[yc][xc].pt3Y;
 	    pv[23] = -halfThick;
 
-	    // 16 indices for 4 sides (for quads)
-	    p->sideIndices = (GLushort *)calloc (4 * 4, sizeof (GLushort));
+	    // 24 indices for 4 sides (for triangles)
+	    p->sideIndices = (GLushort *)calloc (6 * 4, sizeof (GLushort));
 	    if (!p->sideIndices)
 	    {
 		compLogMessage ("animationaddon",
@@ -965,7 +984,9 @@
 	    ind[id++] = 6; // First vertex
 	    ind[id++] = 1;
 	    ind[id++] = 0;
+	    ind[id++] = 6;
 	    ind[id++] = 7;
+	    ind[id++] = 0;
 	    nor[6 * 3 + 0] = -1; // Flat shading only uses 1st vertex's normal
 	    nor[6 * 3 + 1] = 0; // in a polygon, vertex 6 for this face.
 	    nor[6 * 3 + 2] = 0;
@@ -974,7 +995,9 @@
 	    ind[id++] = 1;
 	    ind[id++] = 6;
 	    ind[id++] = 5;
+	    ind[id++] = 1;
 	    ind[id++] = 2;
+	    ind[id++] = 5;
 	    nor[1 * 3 + 0] = 0;
 	    nor[1 * 3 + 1] = 1;
 	    nor[1 * 3 + 2] = 0;
@@ -983,7 +1006,9 @@
 	    ind[id++] = 2;
 	    ind[id++] = 5;
 	    ind[id++] = 4;
+	    ind[id++] = 2;
 	    ind[id++] = 3;
+	    ind[id++] = 4;
 	    nor[2 * 3 + 0] = 1;
 	    nor[2 * 3 + 1] = 0;
 	    nor[2 * 3 + 2] = 0;
@@ -992,7 +1017,9 @@
 	    ind[id++] = 7;
 	    ind[id++] = 0;
 	    ind[id++] = 3;
+	    ind[id++] = 7;
 	    ind[id++] = 4;
+	    ind[id++] = 3;
 	    nor[7 * 3 + 0] = 0;
 	    nor[7 * 3 + 1] = -1;
 	    nor[7 * 3 + 2] = 0;
@@ -1067,8 +1094,11 @@
     if (!matrix.size ())
 	return;
 
-    GLWindow::Geometry &geometry = GLWindow::get (mWindow)->geometry ();
-    geometry.vCount = 1; // Force glDrawGeometry to be called
+    /* Force glDrawTexture to be called by pushing a single vertex into the
+     * window's vertex buffer */
+    GLWindow *gWindow = GLWindow::get (mWindow);
+    GLfloat vertexData[3] = {0.0f, 0.0f, 0.0f};
+    gWindow->vertexBuffer ()->addVertices (1, vertexData);
 
     bool dontStoreClips = true;
 
@@ -1298,56 +1328,62 @@
 }
 
 void
-PolygonAnim::prepareDrawingForAttrib (GLFragment::Attrib &attrib)
-{
-    if (GL::canDoSaturated && attrib.getSaturation () != COLOR)
-    {
-	GLfloat constant[4];
-
-	if (GL::canDoSlightlySaturated && attrib.getSaturation () > 0)
-	{
-	    constant[3] = attrib.getOpacity () / 65535.0f;
-	    constant[0] = constant[1] = constant[2] = constant[3] *
-		attrib.getBrightness () / 65535.0f;
-
-	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
-	}
-	else
-	{
-	    constant[3] = attrib.getOpacity () / 65535.0f;
-	    constant[0] = constant[1] = constant[2] = constant[3] *
-		attrib.getBrightness () / 65535.0f;
-
-	    constant[0] = 0.5f + 0.5f * RED_SATURATION_WEIGHT   * constant[0];
-	    constant[1] = 0.5f + 0.5f * GREEN_SATURATION_WEIGHT * constant[1];
-	    constant[2] = 0.5f + 0.5f * BLUE_SATURATION_WEIGHT  * constant[2];
-
-	    glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
-	}
-    }
-    else
-    {
-	attrib.setBrightness (0.76 * attrib.getBrightness ());
-
-	GLushort color =
-	    (attrib.getOpacity () * attrib.getBrightness ()) >> 16;
-
-	mGScreen->setTexEnvMode (GL_MODULATE);
-	glColor4us (color, color, color, attrib.getOpacity ());
+PolygonAnim::prepareDrawingForAttrib (GLWindowPaintAttrib &attrib,
+                                      GLVertexBuffer      &vertexBuffer)
+{
+    // Disabled for now until lighting can be re-written
+    // attrib.brightness *= 0.76;
+    GLushort color = (attrib.brightness * attrib.opacity) >> 16;
+    GLfloat colorNormalized = color / static_cast <GLfloat> (COLOR);
+
+    vertexBuffer.color4f (colorNormalized,
+                          colorNormalized,
+                          colorNormalized,
+                          attrib.opacity / static_cast <GLfloat> (COLOR));
+}
+
+namespace
+{
+    enum class Winding : int
+    {
+	Clockwise = 0,
+	Counterclockwise = 1
+    };
+
+    /* This function assumes that indices is large enough to
+     * hold a polygon of nSides sides */
+    unsigned int determineIndicesForPolygon (GLushort *indices,
+					     GLushort nSides,
+					     Winding direction)
+    {
+	unsigned int index = 0;
+	bool front = direction == Winding::Counterclockwise;
+
+	for (GLushort i = 2; i < nSides; ++i)
+	{
+	    indices[index] = 0;
+	    indices[index + 1] = (front ? (i - 1) : i);
+	    indices[index + 2] = (front ? i : (i - 1));
+
+	    index += 3;
+	}
+
+	return index;
     }
 }
 
 inline void
-PolygonAnim::drawPolygonClipIntersection (const PolygonObject *p,
+PolygonAnim::drawPolygonClipIntersection (GLTexture *texture,
+					  const GLMatrix &transform,
+					  const PolygonObject *p,
                                           const Clip4Polygons &c,
                                           const GLfloat *vertexTexCoords,
                                           int pass,
                                           float forwardProgress,
-                                          GLdouble clipPlanes[4][4],
                                           const CompOutput &output,
                                           float newOpacity,
                                           bool decelerates,
-                                          GLfloat skewMat[16])
+					  GLMatrix &skewMat)
 {
     int nSides = p->nSides;
     float newOpacityPolygon = newOpacity;
@@ -1386,52 +1422,56 @@
     else if (newOpacityPolygon > 0.9999)	// if fully opaque
 	return;	// draw only non-opaque ones in pass 1
 
-    glPushMatrix ();
+    GLMatrix polygonTransform (transform);
 
     if (mCorrectPerspective == CorrectPerspectivePolygon)
-	getPerspectiveCorrectionMat (p, skewMat, NULL, output);
+	getPerspectiveCorrectionMat (p, NULL, &skewMat, output);
 
     if (mCorrectPerspective != CorrectPerspectiveNone)
-	glMultMatrixf (skewMat);
+	polygonTransform *= skewMat;
 
     // Center
-    glTranslatef (p->centerPos.x (),
-		  p->centerPos.y (),
-		  p->centerPos.z ());
+    polygonTransform.translate (p->centerPos.x (),
+				p->centerPos.y (),
+				p->centerPos.z ());
 
     // Scale z first
-    glScalef (1.0f, 1.0f, 1.0f / ::screen->width ());
+    polygonTransform.scale (1.0f, 1.0f, 1.0f / ::screen->width ());
 
-    transformPolygon (p);
+    transformPolygon (polygonTransform, p);
 
     // Move by "rotation axis offset"
-    glTranslatef (p->rotAxisOffset.x (),
-		  p->rotAxisOffset.y (),
-		  p->rotAxisOffset.z ());
+    polygonTransform.translate (p->rotAxisOffset.x (),
+				p->rotAxisOffset.y (),
+				p->rotAxisOffset.z ());
 
     // Rotate by desired angle
-    glRotatef (p->rotAngle,
-	       p->rotAxis.x (), p->rotAxis.y (), p->rotAxis.z ());
+    polygonTransform.rotate (p->rotAngle,
+			     p->rotAxis.x (),
+			     p->rotAxis.y (),
+			     p->rotAxis.z ());
 
     // Move back to center
-    glTranslatef (-p->rotAxisOffset.x (),
-		  -p->rotAxisOffset.y (),
-		  -p->rotAxisOffset.z ());
+    polygonTransform.translate (-p->rotAxisOffset.x (),
+				-p->rotAxisOffset.y (),
+				-p->rotAxisOffset.z ());
 
     // Scale back
-    glScalef (1.0f, 1.0f, ::screen->width ());
-
-    clipPlanes[0][3] = -(c.boxf.x1 - p->centerPosStart.x ());
-    clipPlanes[1][3] = -(c.boxf.y1 - p->centerPosStart.y ());
-    clipPlanes[2][3] = (c.boxf.x2 - p->centerPosStart.x ());
-    clipPlanes[3][3] = (c.boxf.y2 - p->centerPosStart.y ());
-    glClipPlane (GL_CLIP_PLANE0, clipPlanes[0]);
-    glClipPlane (GL_CLIP_PLANE1, clipPlanes[1]);
-    glClipPlane (GL_CLIP_PLANE2, clipPlanes[2]);
-    glClipPlane (GL_CLIP_PLANE3, clipPlanes[3]);
-
-    for (int k = 0; k < 4; k++)
-	glEnable (GL_CLIP_PLANE0 + k);
+    polygonTransform.scale (1.0f, 1.0f, ::screen->width ());
+
+    // clipPlanes[0][3] = -(c.boxf.x1 - p->centerPosStart.x ());
+    // clipPlanes[1][3] = -(c.boxf.y1 - p->centerPosStart.y ());
+    // clipPlanes[2][3] = (c.boxf.x2 - p->centerPosStart.x ());
+    // clipPlanes[3][3] = (c.boxf.y2 - p->centerPosStart.y ());
+    // Clip planes are not supported on Modern OpenGL
+    //
+    // glClipPlane (GL_CLIP_PLANE0, clipPlanes[0]);
+    // glClipPlane (GL_CLIP_PLANE1, clipPlanes[1]);
+    // glClipPlane (GL_CLIP_PLANE2, clipPlanes[2]);
+    // glClipPlane (GL_CLIP_PLANE3, clipPlanes[3]);
+    // for (int k = 0; k < 4; k++)
+	// glEnable (GL_CLIP_PLANE0 + k);
+
     bool fadeBackAndSides =
 	mBackAndSidesFadeDur > 0 &&
 	forwardProgress <= mBackAndSidesFadeDur;
@@ -1445,56 +1485,92 @@
 	    (forwardProgress / mBackAndSidesFadeDur);
     }
 
-    GLFragment::Attrib attrib = mCurPaintAttrib;
-    attrib.setOpacity (newOpacityPolygon2 * OPAQUE);
+    GLWindowPaintAttrib attrib = mCurPaintAttrib;
+    attrib.opacity = newOpacityPolygon2 * OPAQUE;
 
-    prepareDrawingForAttrib (attrib);
+    GLVertexBuffer *streamingVertexBuffer = GLVertexBuffer::streamingBuffer ();
 
     // Draw back face
-    glVertexPointer (3, GL_FLOAT, 0, p->vertices + 3 * nSides);
-    if (mThickness > 0)
-	glNormalPointer (GL_FLOAT, 0, p->normals + 3 * nSides);
-    else
-	glNormal3f (0.0f, 0.0f, -1.0f);
-    glTexCoordPointer (2, GL_FLOAT, 0, &vertexTexCoords[2 * nSides]);
-    glDrawArrays (GL_POLYGON, 0, nSides);
+    glActiveTexture (GL_TEXTURE0);
+    texture->enable (GLTexture::Fast);
+    streamingVertexBuffer->begin (GL_TRIANGLES);
+    streamingVertexBuffer->addVertices (nSides, p->vertices + 3 * nSides);
+    if (p->normals)
+	streamingVertexBuffer->addNormals (nSides, p->normals + 3 * nSides);
+    streamingVertexBuffer->addTexCoords (0, nSides, &vertexTexCoords[2 * nSides]);
+    if (streamingVertexBuffer->end ())
+    {
+	GLushort indices[64];
+	unsigned int nIndices = determineIndicesForPolygon (indices,
+							    nSides,
+							    Winding::Counterclockwise);
+	streamingVertexBuffer->render (polygonTransform,
+				       attrib,
+				       indices,
+				       nIndices);
+    }
 
-    // Vertex coords
-    glVertexPointer (3, GL_FLOAT, 0, p->vertices);
-    if (mThickness > 0)
-	glNormalPointer (GL_FLOAT, 0, p->normals);
-    else
-	glNormal3f (0.0f, 0.0f, 1.0f);
-    glTexCoordPointer (2, GL_FLOAT, 0, vertexTexCoords);
+    // GL_QUADS uses a different vertex normal than the first
+    // so I use GL_TRIANGLES to make sure the normals are right.
+    texture->disable ();
+    streamingVertexBuffer->begin (GL_TRIANGLES);
+    streamingVertexBuffer->addVertices (p->nVertices, p->vertices);
+    prepareDrawingForAttrib (attrib, *streamingVertexBuffer);
+    if (mThickness > 0 && p->normals)
+	streamingVertexBuffer->addNormals (nSides, p->normals);
 
     // Draw quads for sides
-    for (int k = 0; k < nSides; k++)
+    if (streamingVertexBuffer->end ())
     {
-	// GL_QUADS uses a different vertex normal than the first
-	// so I use GL_POLYGON to make sure the normals are right.
-	glDrawElements (GL_POLYGON, 4,
-		       GL_UNSIGNED_SHORT,
-		       p->sideIndices + k * 4);
+	for (int k = 0; k < nSides; k++)
+	    streamingVertexBuffer->render (polygonTransform,
+					   attrib,
+					   p->sideIndices + k * 6,
+					   6);
     }
 
+    streamingVertexBuffer->colorDefault ();
+
+    texture->enable (GLTexture::Fast);
+    streamingVertexBuffer->begin (GL_TRIANGLES);
     // if opacity was changed just above
     if (fadeBackAndSides)
     {
 	// Go back to normal opacity for front face
 	attrib = mCurPaintAttrib;
-	attrib.setOpacity (newOpacityPolygon * OPAQUE);
-	prepareDrawingForAttrib (attrib);
-    }
-    // Draw front face
-    glDrawArrays (GL_POLYGON, 0, nSides);
-    for (int k = 0; k < 4; k++)
-	glDisable (GL_CLIP_PLANE0 + k);
-
-    glPopMatrix ();
+	attrib.opacity = newOpacityPolygon * OPAQUE;
+    }
+    streamingVertexBuffer->addVertices (nSides, p->vertices);
+    if (p->normals)
+	streamingVertexBuffer->addNormals (nSides, p->normals);
+    streamingVertexBuffer->addTexCoords (0, nSides, vertexTexCoords);
+    if (streamingVertexBuffer->end ())
+    {
+	GLushort indices[64];
+	unsigned int nIndices = determineIndicesForPolygon (indices,
+							    nSides,
+							    Winding::Counterclockwise);
+	streamingVertexBuffer->render (polygonTransform,
+				       attrib,
+				       indices,
+				       nIndices);
+    }
+
+    streamingVertexBuffer->colorDefault ();
+
+    texture->disable ();
+
+    // Clip planes are not supported on Modern OpenGL
+    //
+    // for (int k = 0; k < 4; k++)
+	// glDisable (GL_CLIP_PLANE0 + k);
 }
 
 void
-PolygonAnim::drawGeometry ()
+PolygonAnim::drawGeometry (GLTexture                 *texture,
+			   const GLMatrix            &transform,
+			   const GLWindowPaintAttrib &attrib,
+			   unsigned int              mask)
 {
     mNumDrawGeometryCalls++;
 
@@ -1540,96 +1616,52 @@
 
     // OpenGL stuff starts here
 
-    GLboolean normalArrayWas = false;
-
-    if (mThickness > 0)
-    {
-	glPushAttrib (GL_NORMALIZE);
-	glEnable (GL_NORMALIZE);
-
-	normalArrayWas = glIsEnabled (GL_NORMAL_ARRAY);
-	glEnableClientState (GL_NORMAL_ARRAY);
-    }
-
-    if (mDoLighting)
-    {
-	glPushAttrib (GL_SHADE_MODEL);
-	glShadeModel (GL_FLAT);
-
-	glPushAttrib (GL_LIGHT0);
-	glPushAttrib (GL_COLOR_MATERIAL);
-	glPushAttrib (GL_LIGHTING);
-	glEnable (GL_COLOR_MATERIAL);
-	glEnable (GL_LIGHTING);
-
-	GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 0.3f };
-	GLfloat diffuseLight[] = { 0.9f, 0.9f, 0.9f, 0.9f };
-	GLfloat light0Position[] = { -0.5f, 0.5f, 9.0f, 0.0f };
-
-	glLightfv (GL_LIGHT0, GL_AMBIENT, ambientLight);
-	glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuseLight);
-	glLightfv (GL_LIGHT0, GL_POSITION, light0Position);
-    }
-
-    glPushMatrix ();
-
-    glPushAttrib (GL_STENCIL_BUFFER_BIT);
-    glDisable (GL_STENCIL_TEST);
+    // Lighting will require special shaders, which aren't
+    // implemented right now, so disable it.
+    //
+    // if (mDoLighting)
+    // {
+    //	glPushAttrib (GL_SHADE_MODEL);
+    //	glShadeModel (GL_FLAT);
+    //
+    //	glPushAttrib (GL_LIGHT0);
+    //	glPushAttrib (GL_COLOR_MATERIAL);
+    //	glPushAttrib (GL_LIGHTING);
+    //	glEnable (GL_COLOR_MATERIAL);
+    //	glEnable (GL_LIGHTING);
+    //
+    //	GLfloat ambientLight[] = { 0.3f, 0.3f, 0.3f, 0.3f };
+    //	GLfloat diffuseLight[] = { 0.9f, 0.9f, 0.9f, 0.9f };
+    //	GLfloat light0Position[] = { -0.5f, 0.5f, 9.0f, 0.0f };
+    //
+    //	glLightfv (GL_LIGHT0, GL_AMBIENT, ambientLight);
+    //	glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuseLight);
+    //	glLightfv (GL_LIGHT0, GL_POSITION, light0Position);
+    // }
 
     if (mDoDepthTest)
     {
 	// Depth test
-	glPushAttrib (GL_DEPTH_FUNC);
-	glPushAttrib (GL_DEPTH_TEST);
 	glDepthFunc (GL_LEQUAL);
+	glDepthMask (GL_TRUE);
 	glEnable (GL_DEPTH_TEST);
     }
 
     // Clip planes
-    GLdouble clipPlanes[4][4] = {{ 1, 0, 0, 0 },
-				 { 0, 1, 0, 0 },
-				 { -1, 0, 0, 0 },
-				 { 0, -1, 0, 0 }};
-
-    // Save old color values
-    GLfloat oldColor[4];
-
-    glGetFloatv (GL_CURRENT_COLOR, oldColor);
-
-    // Determine where we are called from in paint.c's drawWindowTexture
-    // to find out how we should change the opacity
-    GLint prevActiveTexture = GL_TEXTURE0_ARB;
-    bool saturationFull = true;
-
-    if (GL::canDoSaturated && mCurPaintAttrib.getSaturation () != COLOR)
-    {
-	saturationFull = false;
-	if (GL::canDoSlightlySaturated &&
-	    mCurPaintAttrib.getSaturation () > 0)
-	{
-	    if (mCurPaintAttrib.getOpacity () < OPAQUE ||
-		mCurPaintAttrib.getBrightness () != BRIGHT)
-		prevActiveTexture = GL_TEXTURE3_ARB;
-	    else
-		prevActiveTexture = GL_TEXTURE2_ARB;
-	}
-	else
-	    prevActiveTexture = GL_TEXTURE1_ARB;
-    }
-
-    float opacity = mCurPaintAttrib.getOpacity () / 65535.0;
+    // GLdouble clipPlanes[4][4] = {{ 1, 0, 0, 0 },
+    //				 { 0, 1, 0, 0 },
+    //				 { -1, 0, 0, 0 },
+    //				 { 0, -1, 0, 0 }};
+
+    float opacity = mCurPaintAttrib.opacity / 65535.0;
 
     float newOpacity = opacity;
     float fadePassedBy;
 
     bool decelerates = deceleratingMotion ();
 
-    glPushAttrib (GL_BLEND);
     glEnable (GL_BLEND);
 
-    if (saturationFull)
-	mGScreen->setTexEnvMode (GL_MODULATE);
-
     // if fade-out duration is not specified per polygon
     if (mAllFadeDuration > -1.0f)
     {
@@ -1657,9 +1689,9 @@
 	static_cast<ExtensionPluginAnimAddon*> (getExtensionPluginInfo ())->
 	output ();
 
-    GLfloat skewMat[16];
+    GLMatrix skewMat;
     if (mCorrectPerspective == CorrectPerspectiveWindow)
-	getPerspectiveCorrectionMat (NULL, skewMat, NULL, *output);
+	getPerspectiveCorrectionMat (NULL, NULL, &skewMat, *output);
 
     // pass: 0: draw opaque ones
     //       1: draw transparent ones
@@ -1673,10 +1705,12 @@
 		const GLfloat *vTexCoords = &c->polygonVertexTexCoords[0];
 		foreach (const PolygonObject *p, mPolygons)
 		{
-		    drawPolygonClipIntersection (p, *c,
+		    drawPolygonClipIntersection (texture,
+						 transform,
+						 p, *c,
 		                                 vTexCoords,
 						 pass, forwardProgress,
-						 clipPlanes, *output,
+						 *output,
 						 newOpacity,
 						 decelerates,
 						 skewMat);
@@ -1688,10 +1722,12 @@
 		foreach (const PolygonClipInfo *pci,
 		         c->intersectingPolygonInfos)
 		{
-		    drawPolygonClipIntersection (pci->p, *c,
+		    drawPolygonClipIntersection (texture,
+						 transform,
+						 pci->p, *c,
 		                                 &pci->vertexTexCoords[0],
 						 pass, forwardProgress,
-						 clipPlanes, *output,
+						 *output,
 						 newOpacity,
 						 decelerates,
 						 skewMat);
@@ -1702,45 +1738,24 @@
     // Restore
     // -----------------------------------------
 
-    // Restore old color values
-    glColor4f (oldColor[0], oldColor[1], oldColor[2], oldColor[3]);
-
-    glPopAttrib (); // GL_BLEND
+    glDisable (GL_BLEND);
 
     if (mDoDepthTest)
     {
-	glPopAttrib (); // GL_DEPTH_TEST
-	glPopAttrib (); // GL_DEPTH_FUNC
-    }
-
-    glPopAttrib (); // GL_STENCIL_BUFFER_BIT
-
-    // Restore texture stuff
-    if (saturationFull)
-	mGScreen->setTexEnvMode (GL_REPLACE);
-
-    glPopMatrix ();
-    (GL::activeTexture) (prevActiveTexture);
-
-    if (mDoLighting)
-    {
-	glPopAttrib (); // GL_LIGHTING
-	glPopAttrib (); // GL_COLOR_MATERIAL
-	glPopAttrib (); // GL_LIGHT0
-	glPopAttrib (); // GL_SHADE_MODEL
-    }
-
-    if (mThickness > 0)
-    {
-	glPopAttrib (); // GL_NORMALIZE
-
-	if (normalArrayWas)
-	    glEnableClientState (GL_NORMAL_ARRAY);
-	else
-	    glDisableClientState (GL_NORMAL_ARRAY);
-    }
-    else
-	glNormal3f (0.0f, 0.0f, -1.0f);
+	glDisable (GL_DEPTH_TEST);
+	glDepthMask (GL_FALSE);
+    }
+
+    // Lighting will require special shaders whcih
+    // are not implemented for now.
+    //
+    // if (mDoLighting)
+    // {
+    //	glPopAttrib (); // GL_LIGHTING
+    //	glPopAttrib (); // GL_COLOR_MATERIAL
+    //	glPopAttrib (); // GL_LIGHT0
+    //	glPopAttrib (); // GL_SHADE_MODEL
+    // }
 
     if (mClipsUpdated)		// set the end mark for this group of clips
 	mLastClipInGroup.push_back (lastClip);
@@ -1760,7 +1775,7 @@
 }
 
 void
-PolygonAnim::postPaintWindow ()
+PolygonAnim::postPaintWindow (const GLMatrix &)
 {
     if (mClipsUpdated &&	// clips should be dropped only in the 1st step
 	mNumDrawGeometryCalls == 0)	// if clips not drawn
@@ -1842,20 +1857,7 @@
 
     prepareTransform (output, wTransform, wTransform2);
 
-    const float *screenProjection = gScreen->projectionMatrix ();
-    GLdouble dModel[16];
-    GLdouble dProjection[16];
-    for (int i = 0; i < 16; i++)
-    {
-	dProjection[i] = screenProjection[i];
-    }
-    GLint viewport[4] =
-	{output.region ()->extents.x1,
-	 output.region ()->extents.y1,
-	 output.width (),
-	 output.height ()};
-    GLdouble px, py, pz;
-
+    GLMatrix *screenProjection = gScreen->projectionMatrix ();
     GLMatrix *modelViewTransform = &wTransform;
 
     GLMatrix skewMat;
@@ -1878,9 +1880,6 @@
 
 	// if modelViewTransform == wTransform2, then
 	// it changes for each polygon
-	const float *modelViewMatrix = modelViewTransform->getMatrix ();
-	for (int j = 0; j < 16; j++)
-	    dModel[j] = modelViewMatrix[j];
 
 	Point3d center = p->centerPos;
 	float radius = p->boundSphereRadius + 2;
@@ -1924,13 +1923,16 @@
 	Point3d *pnt = cubeCorners;
 	for (int j = 0; j < N_POINTS; j++, pnt++)
 	{
-	    if (!gluProject (pnt->x (), pnt->y (), pnt->z (),
-			     dModel, dProjection, viewport,
-			     &px, &py, &pz))
-		return;
+	    namespace com = compiz::opengl::matrix;
+	    CompPoint p (com::projectIntoViewport(*screenProjection,
+						  *modelViewTransform,
+						  output,
+						  GLVector (pnt->x (),
+							    pnt->y (),
+							    pnt->z ())));
 
-	    py = ::screen->height () - py;
-	    mAWindow->expandBBWithPoint (px + 0.5, py + 0.5);
+	    p.setY (::screen->height () - p.y ());
+	    mAWindow->expandBBWithPoint (p.x () + 0.5, p.y () + 0.5);
 	}
 #undef N_POINTS
     }
@@ -1988,9 +1990,16 @@
 	    }
 	}
     }
+
     if (depthUsed)
     {
+#ifdef USE_GLES
+	glClearDepthf (1000.0f);
+#else
 	glClearDepth (1000.0f);
+#endif
+	glDepthMask (GL_TRUE);
 	glClear (GL_DEPTH_BUFFER_BIT);
+	glDepthMask (GL_FALSE);
     }
 }

=== modified file 'plugins/animationaddon/src/private.h'
--- plugins/animationaddon/src/private.h	2013-10-31 15:59:14 +0000
+++ plugins/animationaddon/src/private.h	2016-06-22 01:26:00 +0000
@@ -70,7 +70,7 @@
 };
 
 class AnimAddonWindow :
-    public PluginClassHandler<AnimAddonWindow, CompWindow>
+    public PluginClassHandler<AnimAddonWindow, CompWindow, ANIMATIONADDON_ABI>
 {
 public:
     AnimAddonWindow (CompWindow *);
@@ -224,7 +224,8 @@
 	init ();
 
 	void
-	transformPolygon (const PolygonObject *p);
+	transformPolygon (GLMatrix &matrix,
+			  const PolygonObject *p);
 
 	bool
 	tesselateIntoAirplane ();

=== modified file 'plugins/opengl/include/opengl/matrix.h'
--- plugins/opengl/include/opengl/matrix.h	2012-08-02 11:57:41 +0000
+++ plugins/opengl/include/opengl/matrix.h	2016-06-22 01:26:00 +0000
@@ -26,6 +26,8 @@
 #ifndef _GLMATRIX_H
 #define _GLMATRIX_H
 
+#include <core/point.h>
+#include <core/rect.h>
 #include <opengl/vector.h>
 
 class CompOutput;
@@ -65,4 +67,29 @@
 	float m[16];
 };
 
+namespace compiz
+{
+    namespace opengl
+    {
+	namespace matrix
+	{
+	    /* This function returns co-ordinates into viewport space. In order
+	     * to convert into something like damage rectangles please remember
+	     * to flip on the y axis. */
+	    inline CompPoint projectIntoViewport (const GLMatrix &modelview,
+						  const GLMatrix &projection,
+						  const CompRect &vp,
+						  const GLVector &vector)
+            {
+		    GLVector projected (projection * modelview * vector);
+		    projected.homogenize ();
+		    projected[0] = projected[0] * 0.5 + 0.5;
+		    projected[1] = projected[1] * 0.5 + 0.5;
+		    return CompPoint (projected[0] * vp.width () + vp.x (),
+				      projected[1] * vp.height () + vp.y ());
+	    }
+	}
+    }
+}
+
 #endif

=== modified file 'plugins/opengl/include/opengl/opengl.h'
--- plugins/opengl/include/opengl/opengl.h	2016-05-13 07:57:01 +0000
+++ plugins/opengl/include/opengl/opengl.h	2016-06-22 01:26:00 +0000
@@ -1036,6 +1036,12 @@
 	                 std::string vertex_shader,
 	                 std::string fragment_shader);
 
+	/**
+	 * Use this if overriding glDrawTexture completely - used to clear
+	 * out any internal shader caches.
+	 */
+	void clearShaders ();
+
 	GLTexture *getIcon (int width, int height);
 
 	WRAPABLE_HND (0, GLWindowInterface, bool, glPaint,

=== modified file 'plugins/opengl/include/opengl/vertexbuffer.h'
--- plugins/opengl/include/opengl/vertexbuffer.h	2016-05-12 06:16:56 +0000
+++ plugins/opengl/include/opengl/vertexbuffer.h	2016-06-22 01:26:00 +0000
@@ -113,12 +113,30 @@
 
 	int render (const GLMatrix &modelview);
 
+	int render (const GLushort *indices,
+		    GLuint         nIndices);
+
+	int render (const GLMatrix    &modelview,
+		    const GLushort    *indices,
+		    GLuint            nIndices);
+
 	int render (const GLMatrix            &modelview,
 	            const GLWindowPaintAttrib &attrib);
 
+	int render (const GLMatrix              &modelview,
+		    const GLWindowPaintAttrib   &attrib,
+		    const GLushort              *indices,
+		    GLuint                      nIndices);
+
 	int render (const GLMatrix            &projection,
-	            const GLMatrix            &modelview,
-	            const GLWindowPaintAttrib &attrib);
+		    const GLMatrix            &modelview,
+		    const GLWindowPaintAttrib &attrib);
+
+	int render (const GLMatrix              &projection,
+		    const GLMatrix              &modelview,
+		    const GLWindowPaintAttrib   &attrib,
+		    const GLushort              *indices,
+		    GLuint                      nIndices);
 
 	void setVertexOffset (GLuint vOffset);
 	void setMaxVertices (GLint vMax);

=== modified file 'plugins/opengl/src/paint.cpp'
--- plugins/opengl/src/paint.cpp	2016-05-17 02:52:47 +0000
+++ plugins/opengl/src/paint.cpp	2016-06-22 01:26:00 +0000
@@ -1298,16 +1298,7 @@
 	priv->vertexBuffer->render (transform, attrib);
     #endif
 
-    for (std::list<const GLShaderData*>::const_iterator it = priv->shaders.begin();
-         it != priv->shaders.end();
-         ++it)
-    {
-	if ((*it)->isCached != true)
-	{
-	    delete *it;
-	}
-    }
-    priv->shaders.clear ();
+    clearShaders ();
     texture->disable ();
 
     if (mask & PAINT_WINDOW_BLEND_MASK)

=== modified file 'plugins/opengl/src/privatevertexbuffer.h'
--- plugins/opengl/src/privatevertexbuffer.h	2013-10-31 15:59:14 +0000
+++ plugins/opengl/src/privatevertexbuffer.h	2016-06-22 01:26:00 +0000
@@ -109,10 +109,14 @@
 
 	int render (const GLMatrix            *projection,
 	            const GLMatrix            *modelview,
-	            const GLWindowPaintAttrib *attrib);
+		    const GLWindowPaintAttrib *attrib,
+		    const GLushort            *indices,
+		    GLuint                    nIndices);
 	int legacyRender (const GLMatrix            &projection,
 	                  const GLMatrix            &modelview,
-	                  const GLWindowPaintAttrib &attrib);
+			  const GLWindowPaintAttrib &attrib,
+			  const GLushort            *indices,
+			  GLuint                    nIndices);
 
     public:
 	static GLVertexBuffer *streamingBuffer;

=== modified file 'plugins/opengl/src/vertexbuffer.cpp'
--- plugins/opengl/src/vertexbuffer.cpp	2016-05-12 05:17:55 +0000
+++ plugins/opengl/src/vertexbuffer.cpp	2016-06-22 01:26:00 +0000
@@ -343,7 +343,16 @@
 int GLVertexBuffer::render ()
 {
     if (enabled ())
-	return priv->render (NULL, NULL, NULL);
+	return priv->render (NULL, NULL, NULL, NULL, 0);
+    else
+	return -1;
+}
+
+int GLVertexBuffer::render (const GLushort *indices,
+			    GLuint         nIndices)
+{
+    if (enabled ())
+	return priv->render (NULL, NULL, NULL, indices, nIndices);
     else
 	return -1;
 }
@@ -355,15 +364,42 @@
     return render (modelview, attrib);
 }
 
+int GLVertexBuffer::render (const GLMatrix   &modelview,
+			    const GLushort   *indices,
+			    GLuint           nIndices)
+{
+    const GLWindowPaintAttrib attrib = { OPAQUE, BRIGHT, COLOR, 0, 0, 0, 0 };
+
+    return render (modelview, attrib, indices, nIndices);
+}
+
 int GLVertexBuffer::render (const GLMatrix            &modelview,
                             const GLWindowPaintAttrib &attrib)
 {
     GLScreen *gScreen = GLScreen::get (screen);
     GLMatrix *projection = gScreen->projectionMatrix ();
 
-    return render (*projection, modelview, attrib);
-}
-
+    return render (*projection, modelview, attrib, NULL, 0);
+}
+
+
+int GLVertexBuffer::render (const GLMatrix              &modelview,
+			    const GLWindowPaintAttrib   &attrib,
+			    const GLushort              *indices,
+			    GLuint                      nIndices)
+{
+    GLScreen *gScreen = GLScreen::get (screen);
+    GLMatrix *projection = gScreen->projectionMatrix ();
+
+    return render (*projection, modelview, attrib, indices, nIndices);
+}
+
+int GLVertexBuffer::render (const GLMatrix            &projection,
+			    const GLMatrix            &modelview,
+			    const GLWindowPaintAttrib &attrib)
+{
+    return render (projection, modelview, attrib, NULL, 0);
+}
 
 #if 0
 #define PRINT_MATRIX(m) printMatrix ((m), #m)
@@ -378,9 +414,11 @@
 #define PRINT_MATRIX(m)
 #endif
 
-int GLVertexBuffer::render (const GLMatrix            &projection,
-                            const GLMatrix            &modelview,
-                            const GLWindowPaintAttrib &attrib)
+int GLVertexBuffer::render (const GLMatrix              &projection,
+			    const GLMatrix              &modelview,
+			    const GLWindowPaintAttrib   &attrib,
+			    const GLushort              *indices,
+			    GLuint                      nIndices)
 {
     if (!priv->vertexData.size ())
 	return -1;
@@ -389,9 +427,9 @@
     PRINT_MATRIX(projection);
 
     if (enabled ())
-	return priv->render (&projection, &modelview, &attrib);
+	return priv->render (&projection, &modelview, &attrib, indices, nIndices);
     else
-	return priv->legacyRender (projection, modelview, attrib);
+	return priv->legacyRender (projection, modelview, attrib, indices, nIndices);
 }
 
 PrivateVertexBuffer::PrivateVertexBuffer () :
@@ -431,9 +469,11 @@
     }
 }
 
-int PrivateVertexBuffer::render (const GLMatrix            *projection,
-                                 const GLMatrix            *modelview,
-                                 const GLWindowPaintAttrib *attrib)
+int PrivateVertexBuffer::render (const GLMatrix              *projection,
+				 const GLMatrix              *modelview,
+				 const GLWindowPaintAttrib   *attrib,
+				 const GLushort              *indices,
+				 GLuint                      nIndices)
 {
     GLfloat attribs[3] = {1, 1, 1};
     GLint positionIndex = -1;
@@ -552,11 +592,16 @@
 	tmpProgram->setUniform3f ("paintAttrib", attribs[0], attribs[1], attribs[2]);
     }
 
-
-    glDrawArrays (primitiveType, vertexOffset, maxVertices > 0 ?
-				    std::min (static_cast <int> (vertexData.size () / 3),
-					      maxVertices) :
-				    vertexData.size () / 3);
+    const GLuint nVerticesToDraw = maxVertices > 0 ?
+		std::min (static_cast <int> (vertexData.size () / 3),
+			  maxVertices) :
+		vertexData.size () / 3;
+
+    if (nIndices && indices)
+	glDrawElements (primitiveType, nIndices, GL_UNSIGNED_SHORT, indices);
+    else
+	glDrawArrays (primitiveType, vertexOffset, nVerticesToDraw);
+
     for (int i = 0; i < 4; ++i)
     {
 	if (texCoordIndex[i] != -1)
@@ -578,7 +623,9 @@
 
 int PrivateVertexBuffer::legacyRender (const GLMatrix            &projection,
                                        const GLMatrix            &modelview,
-                                       const GLWindowPaintAttrib &attrib)
+				       const GLWindowPaintAttrib &attrib,
+				       const GLushort            *indices,
+				       GLuint                    nIndices)
 {
     #ifndef USE_GLES
     glMatrixMode (GL_PROJECTION);
@@ -626,10 +673,18 @@
 	glTexCoordPointer (2, GL_FLOAT, 0, &textureData[i][0]);
     }
 
-    glDrawArrays (primitiveType, vertexOffset, maxVertices > 0 ?
-				    std::min (static_cast <int> (vertexData.size () / 3),
-					      maxVertices) :
-				    vertexData.size () / 3);
+    const GLuint nVerticesToDraw = maxVertices > 0 ?
+		std::min (static_cast <int> (vertexData.size () / 3),
+			  maxVertices) :
+		vertexData.size () / 3;
+
+    if (indices && nIndices)
+	glDrawElements (primitiveType,
+			nIndices,
+			GL_UNSIGNED_SHORT,
+			indices);
+    else
+ 	glDrawArrays (primitiveType, vertexOffset, nVerticesToDraw);
 
     glDisableClientState (GL_VERTEX_ARRAY);
     glDisableClientState (GL_NORMAL_ARRAY);

=== modified file 'plugins/opengl/src/window.cpp'
--- plugins/opengl/src/window.cpp	2016-05-13 06:41:03 +0000
+++ plugins/opengl/src/window.cpp	2016-06-22 01:26:00 +0000
@@ -375,6 +375,21 @@
 }
 
 void
+GLWindow::clearShaders ()
+{
+    for (std::list<const GLShaderData*>::const_iterator it = priv->shaders.begin();
+         it != priv->shaders.end();
+         ++it)
+    {
+        if ((*it)->isCached != true)
+        {
+            delete *it;
+        }
+    }
+    priv->shaders.clear ();
+}
+
+void
 PrivateGLWindow::updateFrameRegion (CompRegion &region)
 {
     window->updateFrameRegion (region);