Merge lp:~bitzesmichail/compiz/wizardGLES into lp:compiz/0.9.10

[Michail Bitzes]

Plugin wizard ported to OpenGL|ES.

Use GLVertexBuffer.
Enable building for GLES. Enable architectures armel and armhf.

(LP: #1196003)

Just the OpenGL|ES port. Bug #1195996 not fixed in this branch.

[MC Return (mc-return)]

Hey Michail !

LGTM @ a first glance. I will test this ASAP (on OpenGL hw). :)
But knowing you, I'm sure it is perfect ;)

The merge of this might take a while though, as the release of 0.9.10.0 gets prepared currently...

[MC Return (mc-return)]

This is now tested and worx perfectly as expected. :)
+1

review: Approve

[MC Return (mc-return)]

Andyrock told me trunk is unblocked, so this can still make it to 0.9.10.0 it seems. :)

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'debian/compiz-plugins.install.armel'
--- debian/compiz-plugins.install.armel	2013-02-03 22:55:55 +0000
+++ debian/compiz-plugins.install.armel	2013-07-07 15:20:32 +0000
@@ -44,6 +44,7 @@
 debian/tmp/usr/*/compiz/*wallpaper.*
 debian/tmp/usr/*/compiz/*water.*
 debian/tmp/usr/*/compiz/*winrules.*
+debian/tmp/usr/*/compiz/*wizard.*
 debian/tmp/usr/*/compiz/*wobbly.*
 debian/tmp/usr/*/compiz/*workspacenames.*
 
 
=== modified file 'debian/compiz-plugins.install.armhf'
--- debian/compiz-plugins.install.armhf	2013-02-03 22:55:55 +0000
+++ debian/compiz-plugins.install.armhf	2013-07-07 15:20:32 +0000
@@ -44,6 +44,7 @@
 debian/tmp/usr/*/compiz/*wallpaper.*
 debian/tmp/usr/*/compiz/*water.*
 debian/tmp/usr/*/compiz/*winrules.*
+debian/tmp/usr/*/compiz/*wizard.*
 debian/tmp/usr/*/compiz/*wobbly.*
 debian/tmp/usr/*/compiz/*workspacenames.*
 
 
=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2013-03-08 18:42:22 +0000
+++ plugins/CMakeLists.txt	2013-07-07 15:20:32 +0000
@@ -32,7 +32,6 @@
     set (COMPIZ_DISABLE_PLUGIN_SHOWREPAINT ON)
     set (COMPIZ_DISABLE_PLUGIN_WIDGET ON)
     set (COMPIZ_DISABLE_PLUGIN_THUMBNAIL ON)
-    set (COMPIZ_DISABLE_PLUGIN_WIZARD ON)
 
 endif (BUILD_GLES)
 
 
=== modified file 'plugins/wizard/include/wizard.h'
--- plugins/wizard/include/wizard.h	2010-09-14 01:57:47 +0000
+++ plugins/wizard/include/wizard.h	2013-07-07 15:20:32 +0000
@@ -32,6 +32,11 @@
 #include "wizard_options.h"
 #include "wizard_tex.h"
 
+extern const unsigned short CACHESIZE_FACTOR;
+extern const unsigned short COORD_COMPONENTS;
+extern const unsigned short VERTEX_COMPONENTS;
+extern const unsigned short COLOR_COMPONENTS;
+
 static float
 rRange (float avg, float range)
 {
@@ -147,14 +152,13 @@
 	int      ne;		// Emitter count
 	int      ng;		// GPoint count
 
-	GLfloat *vertices_cache;
-	int     vertex_cache_count;
-	GLfloat *coords_cache;
-	int     coords_cache_count;
-	GLfloat *colors_cache;
-	int     color_cache_count;
-	GLfloat *dcolors_cache;
-	int     dcolors_cache_count;
+	/* Cache used in drawParticles 
+        It's here to avoid multiple mem allocation 
+        during drawing */
+	std::vector<GLfloat>  vertices_cache;
+	std::vector<GLfloat>  coords_cache;
+	std::vector<GLushort> colors_cache;
+	std::vector<GLushort> dcolors_cache;
 };
 
 class WizardScreen :
@@ -183,7 +187,8 @@
 
 	void loadEmitters (ParticleSystem *ps);
 
-	void drawParticles (ParticleSystem * ps);
+	void drawParticles (ParticleSystem *ps,
+			    const GLMatrix &transform);
 
 	void positionUpdate (const CompPoint &pos);
 
 
=== modified file 'plugins/wizard/src/wizard.cpp'
--- plugins/wizard/src/wizard.cpp	2013-05-09 13:43:07 +0000
+++ plugins/wizard/src/wizard.cpp	2013-07-07 15:20:32 +0000
@@ -29,6 +29,18 @@
 
 #include "wizard.h"
 
+/* 3 vertices per triangle, 2 triangles per particle */
+const unsigned short CACHESIZE_FACTOR = 3 * 2;
+
+/* 2 coordinates, x and y */
+const unsigned short COORD_COMPONENTS = CACHESIZE_FACTOR * 2;
+
+/* each vertex is stored as 3 GLfloats */
+const unsigned short VERTEX_COMPONENTS = CACHESIZE_FACTOR * 3;
+
+/* 4 colors, RGBA */
+const unsigned short COLOR_COMPONENTS = CACHESIZE_FACTOR * 4;
+
 static void
 initParticles (int hardLimit, int softLimit, ParticleSystem * ps)
 {
@@ -42,14 +54,10 @@
     ps->lastCount    = 0;
 
     // Initialize cache
-    ps->vertices_cache      = NULL;
-    ps->colors_cache        = NULL;
-    ps->coords_cache        = NULL;
-    ps->dcolors_cache       = NULL;
-    ps->vertex_cache_count  = 0;
-    ps->color_cache_count   = 0;
-    ps->coords_cache_count  = 0;
-    ps->dcolors_cache_count = 0;
+    ps->vertices_cache.clear ();
+    ps->coords_cache.clear ();
+    ps->colors_cache.clear ();
+    ps->dcolors_cache.clear ();
 
     Particle *part = ps->particles;
     int i;
@@ -277,77 +285,41 @@
 }
 
 void
-WizardScreen::drawParticles (ParticleSystem * ps)
+WizardScreen::drawParticles (ParticleSystem *ps,
+			     const GLMatrix &transform)
 {
-    glPushMatrix ();
+    int i, j, k, l;
+
+    /* Check that the cache is big enough */
+    if (ps->vertices_cache.size () < (unsigned int)ps->hardLimit * VERTEX_COMPONENTS)
+	ps->vertices_cache.resize (ps->hardLimit * VERTEX_COMPONENTS);
+
+    if (ps->coords_cache.size () < (unsigned int)ps->hardLimit * COORD_COMPONENTS)
+	ps->coords_cache.resize (ps->hardLimit * COORD_COMPONENTS);
+
+    if (ps->colors_cache.size () < (unsigned int)ps->hardLimit * COLOR_COMPONENTS)
+	ps->colors_cache.resize (ps->hardLimit * COLOR_COMPONENTS);
+
+    if (ps->darken > 0)
+	if (ps->dcolors_cache.size () < (unsigned int)ps->hardLimit * COLOR_COMPONENTS)
+	    ps->dcolors_cache.resize (ps->hardLimit * COLOR_COMPONENTS);
 
     glEnable (GL_BLEND);
+
     if (ps->tex)
     {
 	glBindTexture (GL_TEXTURE_2D, ps->tex);
 	glEnable (GL_TEXTURE_2D);
     }
-    glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
-    /* Check that the cache is big enough */
-    if (ps->hardLimit > ps->vertex_cache_count)
-    {
-	ps->vertices_cache =
-		(GLfloat*) realloc (ps->vertices_cache,
-				    ps->hardLimit * 4 * 3 * sizeof (GLfloat));
-	ps->vertex_cache_count = ps->hardLimit;
-    }
-
-    if (ps->hardLimit > ps->coords_cache_count)
-    {
-	ps->coords_cache =
-		(GLfloat*) realloc (ps->coords_cache,
-				    ps->hardLimit * 4 * 2 * sizeof (GLfloat));
-	ps->coords_cache_count = ps->hardLimit;
-    }
-
-    if (ps->hardLimit > ps->color_cache_count)
-    {
-	ps->colors_cache =
-		(GLfloat*) realloc (ps->colors_cache,
-				    ps->hardLimit * 4 * 4 * sizeof (GLfloat));
-	ps->color_cache_count = ps->hardLimit;
-    }
-
-    if (ps->darken > 0)
-    {
-	if (ps->dcolors_cache_count < ps->hardLimit)
-	{
-	    ps->dcolors_cache =
-		    (GLfloat*) realloc (ps->dcolors_cache,
-					ps->hardLimit * 4 * 4 * sizeof (GLfloat));
-	    ps->dcolors_cache_count = ps->hardLimit;
-	}
-    }
-
-    GLfloat *dcolors  = ps->dcolors_cache;
-    GLfloat *vertices = ps->vertices_cache;
-    GLfloat *coords   = ps->coords_cache;
-    GLfloat *colors   = ps->colors_cache;
-
-    int cornersSize = sizeof (GLfloat) * 8;
-    int colorSize   = sizeof (GLfloat) * 4;
-
-    GLfloat cornerCoords[8] = {0.0, 0.0,
-			       0.0, 1.0,
-			       1.0, 1.0,
-			       1.0, 0.0};
-
-    int numActive = 0;
+
+    i = j = k = l = 0;
 
     Particle *part = ps->particles;
-    int i;
-    for (i = 0; i < ps->hardLimit; i++, part++)
+    int m;
+    for (m = 0; m < ps->hardLimit; m++, part++)
     {
 	if (part->t > 0.0f)
 	{
-	    numActive += 4;
-
 	    float cOff = part->s / 2.;		//Corner offset from center
 
 	    if (part->t > ps->tnew)		//New particles start larger
@@ -360,88 +332,167 @@
 	    float offA = cOff * (cos (part->phi) - sin (part->phi));
 	    float offB = cOff * (cos (part->phi) + sin (part->phi));
 
-	    vertices[0] = part->x - offB;
-	    vertices[1] = part->y - offA;
-	    vertices[2] = 0;
-
-	    vertices[3] = part->x - offA;
-	    vertices[4] = part->y + offB;
-	    vertices[5] = 0;
-
-	    vertices[6] = part->x + offB;
-	    vertices[7] = part->y + offA;
-	    vertices[8] = 0;
-
-	    vertices[9]  = part->x + offA;
-	    vertices[10] = part->y - offB;
-	    vertices[11] = 0;
-
-	    vertices += 12;
-
-	    memcpy (coords, cornerCoords, cornersSize);
-
-	    coords += 8;
-
-	    colors[0] = part->c[0];
-	    colors[1] = part->c[1];
-	    colors[2] = part->c[2];
+	    GLushort r, g, b, a, dark_a;
+
+	    r = part->c[0] * 65535.0f;
+	    g = part->c[1] * 65535.0f;
+	    b = part->c[2] * 65535.0f;
 
 	    if (part->t > ps->tnew)		//New particles start at a == 1
-		colors[3] = part->a + (1. - part->a) * (part->t - ps->tnew)
-			    / (1. - ps->tnew);
+		a = part->a + (1. - part->a) * (part->t - ps->tnew)
+			    / (1. - ps->tnew) * 65535.0f;
 	    else if (part->t < ps->told)	//Old particles fade to a = 0
-		colors[3] = part->a * part->t / ps->told;
+		a = part->a * part->t / ps->told * 65535.0f;
 	    else				//The others have their own a
-		colors[3] = part->a;
-
-	    memcpy (colors + 4, colors, colorSize);
-	    memcpy (colors + 8, colors, colorSize);
-	    memcpy (colors + 12, colors, colorSize);
-
-	    colors += 16;
+		a = part->a * 65535.0f;
+
+	    dark_a = a * ps->darken;
+
+	    //first triangle
+	    ps->vertices_cache[i + 0] = part->x - offB;
+	    ps->vertices_cache[i + 1] = part->y - offA;
+	    ps->vertices_cache[i + 2] = 0;
+
+	    ps->vertices_cache[i + 3] = part->x - offA;
+	    ps->vertices_cache[i + 4] = part->y + offB;
+	    ps->vertices_cache[i + 5] = 0;
+
+	    ps->vertices_cache[i + 6] = part->x + offB;
+	    ps->vertices_cache[i + 7] = part->y + offA;
+	    ps->vertices_cache[i + 8] = 0;
+
+	    //second triangle
+	    ps->vertices_cache[i + 9] = part->x + offB;
+	    ps->vertices_cache[i + 10] = part->y + offA;
+	    ps->vertices_cache[i + 11] = 0;
+
+	    ps->vertices_cache[i + 12] = part->x + offA;
+	    ps->vertices_cache[i + 13] = part->y - offB;
+	    ps->vertices_cache[i + 14] = 0;
+
+	    ps->vertices_cache[i + 15] = part->x - offB;
+	    ps->vertices_cache[i + 16] = part->y - offA;
+	    ps->vertices_cache[i + 17] = 0;
+
+	    i += 18;
+
+	    ps->coords_cache[j + 0] = 0.0;
+	    ps->coords_cache[j + 1] = 0.0;
+
+	    ps->coords_cache[j + 2] = 0.0;
+	    ps->coords_cache[j + 3] = 1.0;
+
+	    ps->coords_cache[j + 4] = 1.0;
+	    ps->coords_cache[j + 5] = 1.0;
+
+	    //second
+	    ps->coords_cache[j + 6] = 1.0;
+	    ps->coords_cache[j + 7] = 1.0;
+
+	    ps->coords_cache[j + 8] = 1.0;
+	    ps->coords_cache[j + 9] = 0.0;
+
+	    ps->coords_cache[j + 10] = 0.0;
+	    ps->coords_cache[j + 11] = 0.0;
+
+	    j += 12;
+
+	    ps->colors_cache[k + 0] = r;
+	    ps->colors_cache[k + 1] = g;
+	    ps->colors_cache[k + 2] = b;
+	    ps->colors_cache[k + 3] = a;
+
+	    ps->colors_cache[k + 4] = r;
+	    ps->colors_cache[k + 5] = g;
+	    ps->colors_cache[k + 6] = b;
+	    ps->colors_cache[k + 7] = a;
+
+	    ps->colors_cache[k + 8] = r;
+	    ps->colors_cache[k + 9] = g;
+	    ps->colors_cache[k + 10] = b;
+	    ps->colors_cache[k + 11] = a;
+
+	    //second
+	    ps->colors_cache[k + 12] = r;
+	    ps->colors_cache[k + 13] = g;
+	    ps->colors_cache[k + 14] = b;
+	    ps->colors_cache[k + 15] = a;
+
+	    ps->colors_cache[k + 16] = r;
+	    ps->colors_cache[k + 17] = g;
+	    ps->colors_cache[k + 18] = b;
+	    ps->colors_cache[k + 19] = a;
+
+	    ps->colors_cache[k + 20] = r;
+	    ps->colors_cache[k + 21] = g;
+	    ps->colors_cache[k + 22] = b;
+	    ps->colors_cache[k + 23] = a;
+
+	    k += 24;
 
 	    if (ps->darken > 0)
 	    {
-		dcolors[0] = colors[0];
-		dcolors[1] = colors[1];
-		dcolors[2] = colors[2];
-		dcolors[3] = colors[3] * ps->darken;
-		memcpy (dcolors + 4, dcolors, colorSize);
-		memcpy (dcolors + 8, dcolors, colorSize);
-		memcpy (dcolors + 12, dcolors, colorSize);
-
-		dcolors += 16;
+		ps->dcolors_cache[l + 0] = r;
+		ps->dcolors_cache[l + 1] = g;
+		ps->dcolors_cache[l + 2] = b;
+		ps->dcolors_cache[l + 3] = dark_a;
+
+		ps->dcolors_cache[l + 4] = r;
+		ps->dcolors_cache[l + 5] = g;
+		ps->dcolors_cache[l + 6] = b;
+		ps->dcolors_cache[l + 7] = dark_a;
+
+		ps->dcolors_cache[l + 8] = r;
+		ps->dcolors_cache[l + 9] = g;
+		ps->dcolors_cache[l + 10] = b;
+		ps->dcolors_cache[l + 11] = dark_a;
+
+		//second
+		ps->dcolors_cache[l + 12] = r;
+		ps->dcolors_cache[l + 13] = g;
+		ps->dcolors_cache[l + 14] = b;
+		ps->dcolors_cache[l + 15] = dark_a;
+
+		ps->dcolors_cache[l + 16] = r;
+		ps->dcolors_cache[l + 17] = g;
+		ps->dcolors_cache[l + 18] = b;
+		ps->dcolors_cache[l + 19] = dark_a;
+
+		ps->dcolors_cache[l + 20] = r;
+		ps->dcolors_cache[l + 21] = g;
+		ps->dcolors_cache[l + 22] = b;
+		ps->dcolors_cache[l + 23] = dark_a;
+
+		l += 24;
 	    }
 	}
     }
-    glEnableClientState (GL_VERTEX_ARRAY);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-    glEnableClientState (GL_COLOR_ARRAY);
-
-    glTexCoordPointer (2, GL_FLOAT, 2 * sizeof (GLfloat), ps->coords_cache);
-    glVertexPointer (3, GL_FLOAT, 3 * sizeof (GLfloat), ps->vertices_cache);
-
-    // darken the background
+
+    GLVertexBuffer *stream = GLVertexBuffer::streamingBuffer ();
+
     if (ps->darken > 0)
     {
 	glBlendFunc (GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
-	glColorPointer (4, GL_FLOAT, 4 * sizeof (GLfloat), ps->dcolors_cache);
-	glDrawArrays (GL_QUADS, 0, numActive);
+	stream->begin (GL_TRIANGLES);
+	stream->addVertices (i / 3, &ps->vertices_cache[0]);
+	stream->addTexCoords (0, j / 2, &ps->coords_cache[0]);
+	stream->addColors (l / 4, &ps->dcolors_cache[0]);
+
+	if (stream->end ())
+	    stream->render (transform);
     }
-    // draw particles
+
+    /* draw particles */
     glBlendFunc (GL_SRC_ALPHA, ps->blendMode);
-
-    glColorPointer (4, GL_FLOAT, 4 * sizeof (GLfloat), ps->colors_cache);
-
-    glDrawArrays (GL_QUADS, 0, numActive);
-
-    glDisableClientState (GL_COLOR_ARRAY);
-    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-    glDisableClientState (GL_VERTEX_ARRAY);
-
-    glPopMatrix ();
-    glColor4usv (defaultColor);
-    gScreen->setTexEnvMode (GL_REPLACE);
+    stream->begin (GL_TRIANGLES);
+
+    stream->addVertices (i / 3, &ps->vertices_cache[0]);
+    stream->addTexCoords (0, j / 2, &ps->coords_cache[0]);
+    stream->addColors (k / 4, &ps->colors_cache[0]);
+
+    if (stream->end ())
+	stream->render (transform);
+
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     glDisable (GL_TEXTURE_2D);
     glDisable (GL_BLEND);
@@ -537,16 +588,9 @@
     if (ps->tex)
 	glDeleteTextures (1, &ps->tex);
 
-    if (ps->vertices_cache)
-	free (ps->vertices_cache);
-    if (ps->colors_cache)
-	free (ps->colors_cache);
-    if (ps->coords_cache)
-	free (ps->coords_cache);
-    if (ps->dcolors_cache)
-	free (ps->dcolors_cache);
 }
 
+
 static void
 genNewParticles (ParticleSystem *ps, Emitter *e)
 {
@@ -874,26 +918,15 @@
 			     CompOutput			*output,
 			     unsigned int		mask)
 {
-    bool           status;
-    GLMatrix  sTransform;
-
-    status = gScreen->glPaintOutput (sa, transform, region, output, mask);
+    bool status = gScreen->glPaintOutput (sa, transform, region, output, mask);
+    GLMatrix sTransform = transform;
 
     if (!ps || !ps->active)
 	return status;
 
-    sTransform.reset ();
-
     sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
-    glPushMatrix ();
-    glLoadMatrixf (sTransform.getMatrix ());
-
-    drawParticles (ps);
-
-    glPopMatrix ();
-
-    glColor4usv (defaultColor);
+    drawParticles (ps, sTransform);
 
     return status;
 }