Merge lp:~ahmed-a-ammar/pigment/pigment-gles2 into lp:~loic.molinari/pigment/trunk

[Ahmed Ammar]

Unmerged revisions

255. By Ahmed Ammar on 2010-05-19

  * configure.ac:
  * src/pgm/gst/pgm-gst-image.c:
  * src/renderers/opengles/Makefile.am:
  * src/renderers/opengles/backend-native.c:
  * src/renderers/opengles/backend-x11.c:
  * src/renderers/opengles/plugin-opengles2.c:
  Implementation for OpenGL ES 2 renderer. Currently supports three texture
  units and no lights.

  * tests/manual/test-geometry-sorting.c:
  * tests/manual/test-gst-image.c:
  Modified tests to use auto renderer selection.

=== modified file 'ChangeLog'
--- ChangeLog	2010-05-19 16:53:41 +0000
+++ ChangeLog	2010-05-19 17:34:31 +0000
@@ -1,3 +1,18 @@
[phone]  Ahmed Ammar  <[e-mail]>
+
+	* configure.ac:
+	* src/pgm/gst/pgm-gst-image.c:
+	* src/renderers/opengles/Makefile.am:
+	* src/renderers/opengles/backend-native.c:
+	* src/renderers/opengles/backend-x11.c:
+	* src/renderers/opengles/plugin-opengles2.c:
+	Implementation for OpenGL ES 2 renderer. Currently supports three texture
+	units and no lights.
+
+	* tests/manual/test-geometry-sorting.c:
+	* tests/manual/test-gst-image.c:
+	Modified tests to use auto renderer selection.
+
 2010-05-19  Loïc Molinari  <[e-mail]>
 
 	Patch by: Ahmed Ammar <[e-mail]>

=== modified file 'configure.ac'
--- configure.ac	2010-05-10 10:09:50 +0000
+++ configure.ac	2010-05-19 17:34:31 +0000
@@ -247,6 +247,8 @@
 
 AC_CHECK_HEADERS([GLES/egl.h], [HAVE_EGL=yes], [HAVE_EGL=no])
 AC_CHECK_HEADERS([GLES/gl.h], [HAVE_GLES=yes], [HAVE_GLES=no])
+AC_CHECK_HEADERS([GLES2/gl2.h], [HAVE_GLES2=yes], [HAVE_GLES2=no])
+AC_CHECK_HEADERS([EGL/egl.h], [HAVE_EGL2=yes], [HAVE_EGL2=no])
 
 AC_ARG_ENABLE(opengles1-gdl,
   AS_HELP_STRING([--enable-opengles1-gdl],[enable build of OpenGL ES 1 renderer using Intel GDL backend]),
@@ -270,6 +272,38 @@
     ],
     [ENABLE_OPENGLES1_X11=no])
 
+AC_ARG_ENABLE(opengles2-x11,
+  AC_HELP_STRING([--enable-opengles2-x11], [enable build of OpenGL ES 2 renderer using X11 backend]),
+    [
+      case "${enableval}" in
+        yes) ENABLE_OPENGLES2_X11=yes ;;
+        no)  ENABLE_OPENGLES2_X11=no ;;
+        *)   AC_MSG_ERROR(bad value ${enableval} for --enable-opengles2-x11) ;;
+      esac
+    ],
+    [ENABLE_OPENGLES2_X11=no])
+
+if test x$HAVE_EGL2 = xyes -a x$HAVE_GLES2 = xyes; then
+   if test x$ENABLE_OPENGLES2_X11 = xyes -a x$HAVE_X11 = xyes; then
+    AC_DEFINE([HAVE_EGL2_X11], [1],
+              [Defined to 1 if the OpenGL ES 2 renderer uses the X11 backend])
+    HAVE_OPENGLES2_PLUGIN="yes"
+    OPENGLES2_BACKEND="(X11 backend)"
+    PGM_GLES2_CFLAGS="$XLIB_CFLAG $GLIB_CFLAGS"
+    PGM_GLES2_LIBS="$XLIB_LIBS $GLIB_LIBS -lGLESv2 -lEGL"
+   else
+    AC_DEFINE([HAVE_EGL2_NATIVE], [1],
+              [Defined to 1 if the OpenGL ES 2 renderer uses the native backend])
+    HAVE_OPENGLES2_PLUGIN="yes"
+    OPENGLES2_BACKEND="(native backend)"
+    PGM_GLES2_CFLAGS="$GLIB_CFLAGS"
+    PGM_GLES2_LIBS="$GLIB_LIBS -lGLESv2 -lEGL"
+   fi
+else
+  HAVE_OPENGLES2_PLUGIN="no"
+  OPENGLES2_BACKEND=""
+fi
+
 if test x$HAVE_EGL = xyes -a x$HAVE_GLES = xyes; then
   if test x$ENABLE_OPENGLES1_GDL = xyes; then
     AC_CHECK_HEADERS([libgdl.h], [HAVE_GDL=yes], [HAVE_GDL=no])
@@ -290,8 +324,8 @@
                 [Defined to 1 if the OpenGL ES 1 renderer uses the X11 backend])
       HAVE_OPENGLES1_PLUGIN="yes"
       OPENGLES1_BACKEND="(X11 backend)"
-      PGM_GLES1_CFLAGS="$GLIB_CFLAGS"
-      PGM_GLES1_LIBS="$GLIB_LIBS -lGLES_CM"
+      PGM_GLES1_CFLAGS="$XLIB_LIBS $GLIB_CFLAGS"
+      PGM_GLES1_LIBS="$XLIB_LIBS $GLIB_LIBS -lGLES_CM -lEGL"
     else
       HAVE_OPENGLES1_PLUGIN="no"
       OPENGLES1_BACKEND=""
@@ -302,7 +336,7 @@
     HAVE_OPENGLES1_PLUGIN="yes"
     OPENGLES1_BACKEND="(native backend)"
     PGM_GLES1_CFLAGS="$GLIB_CFLAGS"
-    PGM_GLES1_LIBS="$GLIB_LIBS -lGLES_CM"
+    PGM_GLES1_LIBS="$GLIB_LIBS -lGLES_CM -lEGL"
   fi
 else
   HAVE_OPENGLES1_PLUGIN="no"
@@ -313,9 +347,19 @@
 AC_SUBST(HAVE_OPENGLES1_PLUGIN)
 AC_SUBST(PGM_GLES1_CFLAGS)
 AC_SUBST(PGM_GLES1_LIBS)
+
+AC_SUBST(OPENGLES2_BACKEND)
+AC_SUBST(HAVE_OPENGLES2_PLUGIN)
+AC_SUBST(PGM_GLES2_CFLAGS)
+AC_SUBST(PGM_GLES2_LIBS)
+
 AM_CONDITIONAL(HAVE_OPENGLES1_PLUGIN_COND, test x$HAVE_OPENGLES1_PLUGIN = xyes)
+AM_CONDITIONAL(HAVE_OPENGLES2_PLUGIN_COND, test x$HAVE_OPENGLES2_PLUGIN = xyes)
+AM_CONDITIONAL(HAVE_OPENGLES_PLUGIN_COND, test x$HAVE_OPENGLES2_PLUGIN = xyes -o x$HAVE_OPENGLES1_PLUGIN = xyes )
 AM_CONDITIONAL(HAVE_EGL_GDL_COND, test x$HAVE_EGL = xyes -a x$HAVE_GLES = xyes -a x$ENABLE_OPENGLES1_GDL = xyes)
 AM_CONDITIONAL(HAVE_EGL_X11_COND, test x$HAVE_EGL = xyes -a x$HAVE_GLES = xyes -a x$ENABLE_OPENGLES1_X11 = xyes)
+AM_CONDITIONAL(HAVE_EGL2_X11_COND, test x$HAVE_EGL2 = xyes -a x$HAVE_GLES2 = xyes -a x$ENABLE_OPENGLES2_X11 = xyes)
+AM_CONDITIONAL(HAVE_EGL2_NATIVE_COND, test x$HAVE_EGL2 = xyes -a x$HAVE_GLES2 = xyes -a x$ENABLE_OPENGLES2_X11 = xno)
 AM_CONDITIONAL(HAVE_EGL_NATIVE_COND, test x$HAVE_EGL = xyes -a x$HAVE_GLES = xyes -a x$ENABLE_OPENGLES1_X11 = xno -a x$ENABLE_OPENGLES1_GDL = xno)
 
 # *** Documentation ***
@@ -448,6 +492,7 @@
 echo "  3D graphics engine:   yes"
 echo "  OpenGL renderer:      ${HAVE_OPENGL_PLUGIN} ${OPENGL_BACKEND}"
 echo "  OpenGL ES 1 renderer: ${HAVE_OPENGLES1_PLUGIN} ${OPENGLES1_BACKEND}"
+echo "  OpenGL ES 2 renderer: ${HAVE_OPENGLES2_PLUGIN} ${OPENGLES2_BACKEND}"
 echo "  GUI classes:          ${HAVE_GUI_CLASSES}"
 echo "  GStreamer classes:    ${HAVE_GST_CLASSES}"
 echo "  GTK+ classes:         ${HAVE_GTK_CLASSES}"

=== modified file 'src/pgm/gst/pgm-gst-image.c'
--- src/pgm/gst/pgm-gst-image.c	2009-11-30 18:52:29 +0000
+++ src/pgm/gst/pgm-gst-image.c	2010-05-19 17:34:31 +0000
@@ -17,6 +17,7 @@
  *
  * Contributor(s):
  *     Loïc Molinari <[e-mail]>
+ *     Ahmed Ammar <[e-mail]>
  */
 
 /**
@@ -47,10 +48,12 @@
 static void pgm_gst_image_map (PgmNode*, PgmRenderer*, gfloat, gfloat);
 static void pgm_gst_image_unmap (PgmNode*);
 
-/* OpenGL ARB fragment program to convert from YV12/I420 planar YCbCr to RGB
- * color space using coefficients from the ITU-R BT.601 standard for SDTV and
- * the equations detailed in the book "Video Demystified, 4th Edition" */
-static const gchar *ycbcr2rgb_bt601_fp =
+/* Shaders converting from YV12/I420 planar YCbCr to RGB color space using
+ * coefficients from the ITU-R BT.601 standard for SDTV and the equations
+ * detailed in the book "Video Demystified, 4th Edition" */
+
+/* OpenGL ARB fragment program */
+static const gchar *ycbcr2rgb_bt601_glarbfp =
     "!!ARBfp1.0"
     "OPTION ARB_precision_hint_fastest;"
     "ATTRIB position = fragment.texcoord[0];"
@@ -65,12 +68,52 @@
     "MUL result.color, fragment.color, color;"
     "END";
 
+/* OpenGL ES 2 shaders */
+static const gchar *ycbcr2rgb_bt601_glslesvp =
+    "uniform mat4 pgm_projection;\n"
+    "uniform mat4 pgm_modelview;\n"
+    "attribute highp vec4 pgm_position;\n"
+    "attribute highp vec4 pgm_color;\n"
+    "attribute highp vec4 pgm_texcoord;\n"
+    "varying highp vec2 frag_texcoord;\n"
+    "varying highp vec4 frag_color;\n"
+    "void main() {\n"
+    "     frag_texcoord = pgm_texcoord.xy;\n"
+    "     frag_color = pgm_color/255.0;\n"
+    "     gl_Position = pgm_projection * pgm_modelview * pgm_position;\n"
+    "}\n";
+static const gchar *ycbcr2rgb_bt601_glslesfp =
+    "uniform sampler2D pgm_texture0;\n"
+    "uniform sampler2D pgm_texture1;\n"
+    "uniform sampler2D pgm_texture2;\n"
+    "varying highp vec2 frag_texcoord;\n"
+    "varying lowp vec4 frag_color;\n"
+    "void main() {"
+    "    const lowp vec4 kcr = vec4( 1.596, -0.813, 0, 0 );\n"
+    "    const lowp vec4 kcb = vec4( 0, -0.391, 2.018, 0 );\n"
+    "    const lowp vec4 kadj = vec4( -0.871, 0.53, -1.082, 0 );\n"
+    "    lowp float y = texture2D(pgm_texture0, frag_texcoord).x;\n"
+    "    lowp float cb = texture2D(pgm_texture1, frag_texcoord).x;\n"
+    "    lowp float cr = texture2D(pgm_texture2, frag_texcoord).x;\n"
+    "    lowp vec4 color = vec4(y * 1.164);\n"
+    "    color += kcr * cr;\n"
+    "    color += kcb * cb;\n"
+    "    color += kadj;\n"
+    "    gl_FragColor = vec4(color.r, color.g, color.b, 1.0);\n"
+    "}\n";
+
 /* Image negociated format */
-typedef enum {
+enum {
     IMAGE_NOT_NEGOCIATED = 0,
     IMAGE_RGB,
     IMAGE_YCBCR
-} ImageNegociatedFormat;
+};
+
+/* Image available shading language */
+enum {
+    IMAGE_SHADING_LANGUAGE_ARBP   = (1 << 0),
+    IMAGE_SHADING_LANGUAGE_GLSLES = (1 << 1)
+} ;
 
 /* Private structure */
 struct _PgmGstImagePimpl {
@@ -86,6 +129,7 @@
     gfloat texture_ratio;
     PgmGstImageLayout layout;
     guint8 negociated_format;
+    guint8 shading_language;
 };
 
 /* GObject type definition */
@@ -158,6 +202,7 @@
     /* pimpl->texture_ratio = 0.0f; */
     pimpl->layout = PGM_GST_IMAGE_SCALED;
     /* pimpl->negociated_format = 0; */
+    /* pimpl->shading_language = 0; */
 }
 
 /* Private functions */
@@ -317,11 +362,18 @@
     pgm_mesh_set_texture (pimpl->mesh, 1, cb);
     pgm_mesh_set_texture (pimpl->mesh, 2, cr);
 
-    /* Since we checked the support for ARB fragment program support for the
-     * mapped renderer in the map virtual function, we can safely apply the
-     * color space conversion shader to the mesh */
-    shader = pgm_shader_new ("arbp", NULL, 0, NULL, 0, ycbcr2rgb_bt601_fp,
-                             strlen (ycbcr2rgb_bt601_fp), 0);
+    /* Since we checked the support for shaders for the mapped renderer in the
+     * map virtual function, we can safely apply the color space conversion
+     * shader to the mesh depending on the supported language */
+    if (pimpl->shading_language & IMAGE_SHADING_LANGUAGE_ARBP)
+        shader = pgm_shader_new ("arbp", NULL, 0, NULL, 0,
+                                 ycbcr2rgb_bt601_glarbfp,
+                                 strlen (ycbcr2rgb_bt601_glarbfp), 0);
+    else
+        shader = pgm_shader_new ("glsles", ycbcr2rgb_bt601_glslesvp,
+                                 strlen (ycbcr2rgb_bt601_glslesvp), NULL, 0,
+                                 ycbcr2rgb_bt601_glslesfp,
+                                 strlen (ycbcr2rgb_bt601_glslesfp), 0);
     pgm_mesh_set_shader (pimpl->mesh, shader);
 
     /* Store the texture ratio, no need to check for a height of 0 since such a
@@ -410,7 +462,20 @@
         if (strcmp (sl->language, "arbp") == 0)
         {
             if (sl->programs | PGM_RENDERER_FRAGMENT_PROGRAM)
-                formats |= PGM_GST_BASE_YCBCR;
+            {
+                formats |= PGM_GST_BASE_YCBCR;
+                pimpl->shading_language = IMAGE_SHADING_LANGUAGE_ARBP;
+            }
+            break;
+        }
+        else if (strcmp (sl->language, "glsles") == 0)
+        {
+            if (sl->programs | PGM_RENDERER_FRAGMENT_PROGRAM
+                && sl->programs | PGM_RENDERER_VERTEX_PROGRAM)
+            {
+                formats |= PGM_GST_BASE_YCBCR;
+                pimpl->shading_language = IMAGE_SHADING_LANGUAGE_GLSLES;
+            }
             break;
         }
         walk = walk->next;
@@ -536,7 +601,6 @@
     /* Set up the initial average position */
     pgm_mesh_set_average_position (pimpl->mesh, x + pimpl->width * 0.5f,
                                    y + pimpl->height * 0.5f, z);
-
     return PGM_NODE (image);
 }
 

=== modified file 'src/renderers/opengles/Makefile.am'
--- src/renderers/opengles/Makefile.am	2009-11-04 17:50:39 +0000
+++ src/renderers/opengles/Makefile.am	2010-05-19 17:34:31 +0000
@@ -1,7 +1,18 @@
-if HAVE_OPENGLES1_PLUGIN_COND
+if HAVE_OPENGLES_PLUGIN_COND
 
 plugindir = @PLUGIN_PATH@
+
+if HAVE_OPENGLES1_PLUGIN_COND 
+if HAVE_OPENGLES2_PLUGIN_COND 
+plugin_LTLIBRARIES = libpgmopengles1.la libpgmopengles2.la
+else
 plugin_LTLIBRARIES = libpgmopengles1.la
+endif
+else
+plugin_LTLIBRARIES = libpgmopengles2.la
+endif
+
+if HAVE_OPENGLES1_PLUGIN_COND
 
 libpgmopengles1_la_DEPENDENCIES = \
 	$(top_builddir)/src/pgm/libpigment-@PGM_MAJORMINOR@.la
@@ -39,3 +50,40 @@
 noinst_HEADERS = backend.h
 
 endif
+
+if HAVE_OPENGLES2_PLUGIN_COND
+
+
+libpgmopengles2_la_DEPENDENCIES = \
+	$(top_builddir)/src/pgm/libpigment-@PGM_MAJORMINOR@.la
+
+if HAVE_EGL2_NATIVE_COND
+libpgmopengles2_la_SOURCES = \
+	plugin-opengles2.c \
+	backend-native.c
+endif
+if HAVE_EGL2_X11_COND
+libpgmopengles2_la_SOURCES = \
+	plugin-opengles2.c \
+	backend-x11.c
+endif
+
+# egl.h contains non-strictly prototyped function declarations
+libpgmopengles2_la_CFLAGS = \
+	-I$(top_srcdir)/src -DHAVE_GLES2 \ 
+	$(PGM_CFLAGS) -Wno-strict-prototypes \
+	$(PGM_GLES2_CFLAGS)
+
+libpgmopengles2_la_LIBADD = \
+	$(top_builddir)/src/pgm/libpigment-@PGM_MAJORMINOR@.la \
+	$(PGM_GLES2_LIBS)
+
+libpgmopengles2_la_LDFLAGS = $(PGM_PLUGIN_LDFLAGS)
+
+libpgmopengles2_la_LIBTOOLFLAGS = --tag=disable-static
+
+noinst_HEADERS = backend.h
+
+endif
+
+endif

=== modified file 'src/renderers/opengles/backend-native.c'
--- src/renderers/opengles/backend-native.c	2010-05-11 08:42:10 +0000
+++ src/renderers/opengles/backend-native.c	2010-05-19 17:34:31 +0000
@@ -17,6 +17,7 @@
  *
  * Contributor(s):
  *     Loïc Molinari <[e-mail]>
+ *     Ahmed Ammar <[e-mail]>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -24,7 +25,12 @@
 #endif /* HAVE_CONFIG_H */
 
 #include "backend.h"
+
+#ifdef HAVE_GLES2
+#include <EGL/egl.h>
+#else
 #include <GLES/egl.h>
+#endif
 
 /* Private structure */
 typedef struct {
@@ -87,9 +93,21 @@
         EGL_GREEN_SIZE, 6,
         EGL_BLUE_SIZE, 5,
         EGL_DEPTH_SIZE, 16,
+#ifdef HAVE_GLES2
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+#else        
         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
+#endif
         EGL_NONE
     };
+
+    const EGLint context_attribs[] = {
+#ifdef HAVE_GLES2
+      EGL_CONTEXT_CLIENT_VERSION,   2,
+#endif
+      EGL_NONE
+    };
+
     const gchar *version, *vendor, *extensions;
     BackendNative *native;
     EGLConfig config;
@@ -106,6 +124,9 @@
         PGM_ERROR_OBJECT (native->rdr, "can't open default display");
         return NULL;
     }
+ 
+    eglBindAPI(EGL_OPENGL_ES_API);
+
     if (eglInitialize (native->dpy, NULL, NULL) == EGL_FALSE)
     {
         print_egl_error (native->rdr, "eglInitialize");
@@ -142,7 +163,7 @@
         return NULL;
     }
     native->context = eglCreateContext (native->dpy, config,
-                                        EGL_NO_CONTEXT, NULL);
+                                        EGL_NO_CONTEXT, context_attribs);
     if (native->context == EGL_NO_CONTEXT)
     {
         print_egl_error (native->rdr, "eglCreateContext");

=== modified file 'src/renderers/opengles/backend-x11.c'
--- src/renderers/opengles/backend-x11.c	2010-05-11 08:42:10 +0000
+++ src/renderers/opengles/backend-x11.c	2010-05-19 17:34:31 +0000
@@ -17,6 +17,7 @@
  *
  * Contributor(s):
  *     Loïc Molinari <[e-mail]>
+ *     Ahmed Ammar <[e-mail]>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -25,7 +26,11 @@
 
 #include "backend.h"
 #include <string.h> /* memset */
+#ifdef HAVE_GLES2
+#include <EGL/egl.h>
+#else
 #include <GLES/egl.h>
+#endif
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
@@ -643,8 +648,19 @@
         EGL_GREEN_SIZE, 8,
         EGL_BLUE_SIZE, 8,
         EGL_DEPTH_SIZE, 0,
+#ifdef HAVE_GLES2
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+#endif
         EGL_NONE
     };
+    
+    const EGLint context_attribs[] = {
+#ifdef HAVE_GLES2
+      EGL_CONTEXT_CLIENT_VERSION,   2,
+#endif
+      EGL_NONE
+    };
+
     const gchar *version, *vendor, *extensions;
     BackendX11 *x11;
     EGLConfig config;
@@ -670,6 +686,9 @@
         g_slice_free1 (sizeof (BackendX11), x11);
         return NULL;
     }
+
+    eglBindAPI(EGL_OPENGL_ES_API);
+
     if (eglInitialize (x11->egldpy, NULL, NULL) == EGL_FALSE)
     {
         print_egl_error (x11->rdr, "eglInitialize");
@@ -709,7 +728,8 @@
         g_slice_free1 (sizeof (BackendX11), x11);
         return NULL;
     }
-    x11->context = eglCreateContext (x11->egldpy, config, EGL_NO_CONTEXT, NULL);
+    x11->context = eglCreateContext (x11->egldpy, config, 
+                                     EGL_NO_CONTEXT, context_attribs);
     if (x11->context == EGL_NO_CONTEXT)
     {
         print_egl_error (x11->rdr, "eglCreateContext");
@@ -856,16 +876,17 @@
     {
         case PGM_RENDERER_LEFT_ARROW:
         XDefineCursor (x11->dpy, x11->win, XCreateFontCursor
-                       (x11->dpy, XC_top_left_arrow));
+                       (x11->dpy, XC_left_ptr));
         break;
 
         case PGM_RENDERER_INHERIT:
         XDefineCursor (x11->dpy, x11->win, XCreateFontCursor
-                       (x11->dpy, XC_top_left_arrow));
+                       (x11->dpy, XC_left_ptr));
         break;
 
-        case PGM_RENDERER_NONE:
-        XDefineCursor (x11->dpy, x11->win, x11->none_cursor);
+        case PGM_RENDERER_FLEUR:
+        XDefineCursor (x11->dpy, x11->win,
+                       XCreateFontCursor (x11->dpy, XC_fleur));
         break;
 
         default:

=== added file 'src/renderers/opengles/plugin-opengles2.c'
--- src/renderers/opengles/plugin-opengles2.c	1970-01-01 00:00:00 +0000
+++ src/renderers/opengles/plugin-opengles2.c	2010-05-19 17:34:31 +0000
@@ -0,0 +1,838 @@
+/*
+ * Pigment 3D graphics engine
+ * Rendering plugin based on OpenGL ES 1
+ *
+ * Copyright © 2006-2010 Fluendo Embedded S.L.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option) any
+ * later version. This library is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+ * General Public License for more details. You should have received a copy of
+ * the GNU Lesser General Public License along with this library; if not, write
+ * to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * Contributor(s):
+ *     Loïc Molinari <[e-mail]>
+ *     Ahmed Ammar <[e-mail]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include "backend.h"
+#include <string.h> /* strlen */
+#include <ctype.h> /* isdigit */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#define GL_GLEXT_PROTOTYPES
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#undef GL_GLEXT_PROTOTYPES
+
+/* Extension constants */
+enum {
+    EXT_BGRA            = 0x80e1,
+    EXT_MIRRORED_REPEAT = 0x8370
+};
+
+/* Extension flags */
+enum {
+    FLAG_TEXTURE_FORMAT_BGRA8888   = (1 << 0) ,
+    FLAG_TEXTURE_STREAM            = (1 << 1)
+/*    FLAG_BLEND_FUNC_SEPARATE     = (1 << 1) */
+};
+
+/* OpenGL ES 2 attributes */
+enum {
+    PGM_APOSITION   = 0,
+    PGM_ACOLOR      = 1,
+    PGM_ATEXCOORD   = 2,
+};
+
+/* IMG texture stream structure */
+typedef struct {
+    int number;
+    int width;
+    int height;
+    int format;
+} PluginOpengles2TextureBuffer;
+
+/* OpenGL ES 2 vertex shader */
+static const gchar *default_glslesvp =
+    "uniform mat4 pgm_projection;\n"
+    "uniform mat4 pgm_modelview;\n"
+    "attribute highp vec4 pgm_position;\n"
+    "attribute mediump vec4 pgm_color;\n"
+    "attribute mediump vec4 pgm_texcoord;\n"
+    "varying mediump vec2 frag_texcoord;\n"
+    "varying mediump vec4 frag_color;\n"
+    "void main() {\n"
+    "     frag_texcoord = pgm_texcoord.xy;\n"
+    "     frag_color = pgm_color/255.0;\n"
+    "     gl_Position = pgm_projection * pgm_modelview * pgm_position;\n"
+    "}\n";
+static const gchar *default_glslesfp =
+    "uniform sampler2D pgm_texture0;\n"
+    "varying mediump vec2 frag_texcoord;\n"
+    "varying mediump vec4 frag_color;\n"
+    "void main() {\n"
+    "     highp vec4 tex0 = texture2D(pgm_texture0, frag_texcoord);\n"
+    "     gl_FragColor.rgb = frag_color.rgb + tex0.rgb;\n"
+    "     gl_FragColor.a = frag_color.a * tex0.a;\n"
+    "}\n";
+
+/* Wrapper for the opaque PgmPluginTexture pointer */
+typedef struct {
+    GLenum type;
+    GLenum format;
+    GLuint id;
+    gfloat sx;
+    gfloat sy;
+    guint16 width;
+    guint16 height;
+    guint16 miplevels;
+} PluginOpengles2Texture;
+
+/* Wrapper for the opaque PgmPluginShader type */
+typedef struct {
+   GLuint vert_index, frag_index, prog_index;
+   GLint proj_index, modelview_index;
+   GLint texture0_index, texture1_index, texture2_index;
+} PluginOpengles2Shader;
+
+/* IMG texture stream functions */
+typedef void (*glGetTexAttrFunc) (GLenum target, GLenum pname, GLint *params);
+typedef void (*glTexBindStreamFunc) (GLint device, GLint deviceoffset);
+typedef const GLubyte *(*glGetTexDeviceFunc) (GLenum target);
+
+/* Extension functions */
+typedef struct {
+    /* IMG texture stream functions */
+    glTexBindStreamFunc glTexBindStreamIMG;
+    glGetTexAttrFunc glGetTexAttrIMG;
+    glGetTexDeviceFunc glGetTexDeviceIMG;
+} Opengles2ExtensionFunctions;
+
+/* Wrapper for the opaque PgmPlugin pointer */
+typedef struct {
+    PgmPluginFuncs *funcs;
+    PgmRendererCapabilities *caps;
+    PluginOpengles2Texture *default_texture;
+    PgmRenderer *rdr;
+    Backend *backend;
+    PluginOpengles2Texture *texture;
+    gint32 max_texture_units;
+    guint8 extension_flags;
+    /* GLES2 shader variables */
+    PluginOpengles2Shader *shader;
+    GLfloat *proj_mat, *modelview_mat;
+} PluginOpengles2;
+
+/* Texture target look-up table */
+static const GLenum texture_target[] = {
+    GL_TEXTURE_2D,          /* PGM_TEXTURE_2D */
+    0                       /* PGM_TEXTURE_CUBE */     /* Not supported */
+};
+
+/* Texture format look-up table */
+static const GLenum texture_format[] = {
+    GL_LUMINANCE,       /* PGM_TEXTURE_L8 */
+    GL_LUMINANCE_ALPHA, /* PGM_TEXTURE_L8A8 */
+    GL_RGB,             /* PGM_TEXTURE_R8G8B8 */
+    GL_RGB,             /* PGM_TEXTURE_B8G8R8 */   /* Not supported */
+    GL_RGBA,            /* PGM_TEXTURE_R8G8B8A8 */
+    GL_RGBA             /* PGM_TEXTURE_B8G8R8A8 */ /* Not supported */
+};
+
+/* Plugin functions */
+static void
+set_sync_to_vblank (PluginOpengles2 *plugin,
+                    gboolean sync)
+{
+    backend_set_sync_to_vblank (plugin->backend, sync);
+}
+
+static void
+wait_for_vblank (PluginOpengles2 *plugin)
+{
+    backend_wait_for_vblank (plugin->backend);
+}
+
+static void
+clear_buffers (PluginOpengles2 *plugin,
+               PgmPluginClearBuffer flags)
+{
+    /* Stencil buffer's not used in Pigment, but graphics hardware stores depth
+     * and stencil information in the same buffer so for best performance it's
+     * recommended that both depth and stencil be cleared together. As a side
+     * note, in the old times filling pixels was expensive and avoided as best
+     * as possible using convoluted tricks, nowadays this is not true anymore.
+     * Modern cards now support buffer compression and fast clearing of buffers
+     * using a constant color. More informations can be found in GPU
+     * manufacturer's architecture and performance papers. */
+
+    /* FIXME: Is that valid for embedded GPUs? */
+
+    const GLbitfield mask[] = {
+        0,
+        GL_COLOR_BUFFER_BIT,
+        GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT,
+        GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
+    };
+    glClear (mask[flags]);
+}
+
+static void
+set_clear_color (PluginOpengles2 *plugin,
+                 PgmVec4 *color)
+{
+    glClearColor (color->v[0], color->v[1], color->v[2], color->v[3]);
+}
+
+static void
+set_viewport (PluginOpengles2 *plugin,
+              gint32 x,
+              gint32 y,
+              gint32 width,
+              gint32 height)
+{
+    glViewport (x, y, width, height);
+}
+
+static void
+set_projection_matrix (PluginOpengles2 *plugin,
+                       PgmMat4x4 *matrix)
+{
+    const GLfloat transpose[16] = {
+        matrix->m[0], matrix->m[4], matrix->m[8], matrix->m[12],
+        matrix->m[1], matrix->m[5], matrix->m[9], matrix->m[13],
+        matrix->m[2], matrix->m[6], matrix->m[10], matrix->m[14],
+        matrix->m[3], matrix->m[7], matrix->m[11], matrix->m[15]
+    };
+
+    memcpy(plugin->proj_mat, transpose, 16*sizeof(GLfloat));
+    glUniformMatrix4fv(plugin->shader->proj_index, 1, GL_FALSE, plugin->proj_mat);
+}
+
+static void
+set_modelview_matrix (PluginOpengles2 *plugin,
+                      PgmMat4x4 *matrix)
+{
+    const GLfloat transpose[16] = {
+        matrix->m[0], matrix->m[4], matrix->m[8], matrix->m[12],
+        matrix->m[1], matrix->m[5], matrix->m[9], matrix->m[13],
+        matrix->m[2], matrix->m[6], matrix->m[10], matrix->m[14],
+        matrix->m[3], matrix->m[7], matrix->m[11], matrix->m[15]
+    };
+
+    memcpy(plugin->modelview_mat, transpose, 16*sizeof(GLfloat));
+    glUniformMatrix4fv(plugin->shader->modelview_index, 1, GL_FALSE, plugin->modelview_mat);
+}
+
+static void
+draw_primitive (PluginOpengles2 *plugin,
+                gpointer positions,
+                PgmVertexBufferType position_type,
+                guint8 position_size,
+                gpointer colors,
+                PgmVertexBufferType color_type,
+                gpointer texcoords,
+                PgmVertexBufferType texcoord_type,
+                guint8 texcoord_size,
+                guint16 *indices,
+                PgmMeshPrimitiveType primitive_type,
+                guint16 index_count)
+{
+    static const GLenum type[] = {
+        0,                 /* PGM_VERTEX_BUFFER_NONE */
+        GL_BYTE,           /* PGM_VERTEX_BUFFER_INT8 */
+        GL_UNSIGNED_BYTE,  /* PGM_VERTEX_BUFFER_UINT8 */
+        GL_SHORT,          /* PGM_VERTEX_BUFFER_INT16 */
+        GL_UNSIGNED_SHORT, /* PGM_VERTEX_BUFFER_UINT16 */
+        0,                 /* PGM_VERTEX_BUFFER_INT32 */
+        0,                 /* PGM_VERTEX_BUFFER_UINT32 */
+        GL_FLOAT           /* PGM_VERTEX_BUFFER_FLOAT */
+    };
+    static const GLenum mode[] = {
+        GL_LINES,         /* PGM_MESH_LINE_LIST */
+        GL_LINE_STRIP,    /* PGM_MESH_LINE_STRIP */
+        GL_TRIANGLES,     /* PGM_MESH_TRIANGLE_LIST */
+        GL_TRIANGLE_STRIP /* PGM_MESH_TRIANGLE_STRIP */
+    };
+    
+    glVertexAttribPointer(PGM_APOSITION, position_size, type[position_type], GL_FALSE, 0, positions);
+    if (texcoord_type == PGM_VERTEX_BUFFER_NONE) {
+      glEnableVertexAttribArray(PGM_ACOLOR);
+      glVertexAttribPointer(PGM_ACOLOR, 4, type[color_type], GL_FALSE, 0, colors);
+      glDrawElements (mode[primitive_type], index_count, GL_UNSIGNED_SHORT, indices);
+      glDisableVertexAttribArray(PGM_ACOLOR);
+    } else {
+      glEnableVertexAttribArray(PGM_ATEXCOORD);
+      glVertexAttribPointer(PGM_ATEXCOORD, texcoord_size, type[texcoord_type], GL_FALSE, 0, texcoords);
+      glDrawElements (mode[primitive_type], index_count, GL_UNSIGNED_SHORT, indices);
+      glDisableVertexAttribArray(PGM_ATEXCOORD);
+    }
+}
+
+static PgmPluginTexture
+create_texture (PluginOpengles2 *plugin,
+                PgmTextureTarget target,
+                PgmTextureFormat format,
+                guint16 width,
+                guint16 height)
+{
+    PluginOpengles2Texture *texture = g_slice_new (PluginOpengles2Texture);
+
+    texture->type = texture_target[target];
+    texture->format = texture_format[format];
+    texture->width = width;
+    texture->height = height;
+    texture->miplevels = 0;
+
+    glGenTextures (1, &texture->id);
+
+    return (PgmPluginTexture) texture;
+}
+
+static void
+delete_textures (PluginOpengles2 *plugin,
+                 PluginOpengles2Texture **textures,
+                 guint16 count)
+{
+    guint32 i;
+
+    for (i = 0; i < count; i++)
+    {
+        glDeleteTextures (1, &textures[i]->id);
+        g_slice_free (PluginOpengles2Texture, textures[i]);
+    }
+}
+
+static void
+bind_texture (PluginOpengles2 *plugin,
+              guint8 unit,
+              PluginOpengles2Texture *texture)
+{
+    if (unit < plugin->max_texture_units)
+    {
+        glActiveTexture (GL_TEXTURE0 + unit);
+        if (texture != NULL)
+          glBindTexture (texture->type, texture->id);
+        else
+          glBindTexture (GL_TEXTURE_2D, 0);
+        plugin->texture = texture;
+    }
+    else
+    {
+        PGM_WARN_OBJECT (plugin->rdr, "texture unit %d not available on "
+                         "that OpenGL ES 2 implementation", unit);
+    }
+}
+
+static void
+upload_texture (PluginOpengles2 *plugin,
+                guint16 miplevel,
+                guint16 x_offset,
+                guint16 y_offset,
+                guint16 width,
+                guint16 height,
+                gpointer texels)
+{
+    PluginOpengles2Texture *tex = plugin->texture;
+
+    static int idx = 0;
+    if (tex->miplevels & (1 << miplevel))
+    {
+        glTexSubImage2D (tex->type, miplevel, x_offset, y_offset, width,
+                         height, tex->format, GL_UNSIGNED_BYTE, texels);
+    }
+    else
+    {
+        glTexImage2D (tex->type, miplevel, tex->format, tex->width, tex->height,
+                      0, tex->format, GL_UNSIGNED_BYTE, NULL);
+        glTexSubImage2D (tex->type, miplevel, x_offset, y_offset, width, height,
+                         tex->format, GL_UNSIGNED_BYTE, texels);
+        tex->miplevels |= 1 << miplevel;
+    }
+ }
+
+static void
+set_texture_states (PluginOpengles2 *plugin,
+                    PgmTextureFilter min_filter,
+                    PgmTextureFilter mag_filter,
+                    PgmTextureFilter mip_filter,
+                    PgmTextureWrapping wrap_u,
+                    PgmTextureWrapping wrap_v)
+{
+    static const GLenum map[] = {
+        0,          /* PGM_TEXTURE_NONE */
+        GL_NEAREST, /* PGM_TEXTURE_NEAREST */
+        GL_LINEAR,  /* PGM_TEXTURE_LINEAR */
+        GL_NEAREST_MIPMAP_NEAREST,
+        GL_LINEAR_MIPMAP_NEAREST,
+        GL_NEAREST_MIPMAP_LINEAR,
+        GL_LINEAR_MIPMAP_LINEAR
+    };
+    static const GLenum wrap[] = {
+        GL_CLAMP_TO_EDGE,   /* PGM_PLUGIN_CLAMP */
+        GL_CLAMP_TO_EDGE,   /* PGM_PLUGIN_BORDER */
+        GL_REPEAT,          /* PGM_PLUGIN_REPEAT */
+        EXT_MIRRORED_REPEAT /* PGM_PLUGIN_MIRROR */
+    };
+    const GLenum type = plugin->texture->type;
+    glTexParameteri (type, GL_TEXTURE_MIN_FILTER, map[min_filter+mip_filter*2]);
+    glTexParameteri (type, GL_TEXTURE_MAG_FILTER, map[mag_filter]);
+    glTexParameteri (type, GL_TEXTURE_WRAP_S, wrap[wrap_u]);
+    glTexParameteri (type, GL_TEXTURE_WRAP_T, wrap[wrap_v]);
+}
+
+static PgmPluginShader
+create_shader (PluginOpengles2 *plugin,
+               const gchar *language,
+               gpointer vertex_program,
+               gsize vertex_program_size,
+               gpointer geometry_program,
+               gsize geometry_program_size,
+               gpointer fragment_program,
+               gsize fragment_program_size,
+               PgmShaderUniformInfo *uniforms_info,
+               guint8 uniforms_count)
+{
+    PluginOpengles2Shader *shader;
+    gint error_position = 0;
+    GLint success;
+
+    /* XXX Check language validity */
+
+    shader = g_slice_new (PluginOpengles2Shader);
+
+    shader->prog_index = glCreateProgram();
+
+    if ((vertex_program != NULL) || (fragment_program != NULL))
+    {
+      if (vertex_program != NULL)
+      {
+        PGM_INFO_OBJECT(plugin->rdr, "%s: creating new vertex shader\n", __func__);
+        shader->vert_index =   glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(shader->vert_index, 1, (const char**) &vertex_program, (GLint *) &vertex_program_size);
+        glCompileShader(shader->vert_index);
+        glGetShaderiv(shader->vert_index, GL_COMPILE_STATUS, &success);
+        if (!success)  PGM_WARN_OBJECT (plugin->rdr, "%s: vertex shader compilation error\n", __func__);
+        else glAttachShader(shader->prog_index, shader->vert_index);
+      }
+
+      if (fragment_program != NULL)
+      { 
+        PGM_INFO_OBJECT(plugin->rdr, "%s: creating new fragment shader\n", __func__);
+        shader->frag_index =   glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(shader->frag_index, 1, (const char**) &fragment_program, (GLint *) &fragment_program_size);
+        glCompileShader(shader->frag_index);
+        glGetShaderiv(shader->frag_index, GL_COMPILE_STATUS, &success);
+        if (!success)  PGM_WARN_OBJECT (plugin->rdr, "%s: fragment shader compilation error\n", __func__);
+        else glAttachShader(shader->prog_index, shader->frag_index);
+      }
+
+      /* Bind attributes */
+      glBindAttribLocation(shader->prog_index, PGM_APOSITION, "pgm_position");
+      glBindAttribLocation(shader->prog_index, PGM_ACOLOR, "pgm_color");
+      glBindAttribLocation(shader->prog_index, PGM_ATEXCOORD, "pgm_texcoord");
+
+      glLinkProgram(shader->prog_index);
+      glGetProgramiv(shader->prog_index, GL_LINK_STATUS, &success);
+      if (success)  
+      {
+        glUseProgram(shader->prog_index);
+          /* Get uniform locations */
+        shader->proj_index = glGetUniformLocation(shader->prog_index, "pgm_projection");
+        shader->modelview_index = glGetUniformLocation(shader->prog_index, "pgm_modelview");
+
+        shader->texture0_index = glGetUniformLocation(shader->prog_index,"pgm_texture0");
+        glUniform1i(shader->texture0_index, 0);
+        shader->texture1_index = glGetUniformLocation(shader->prog_index,"pgm_texture1");
+        glUniform1i(shader->texture1_index, 1);
+        shader->texture2_index = glGetUniformLocation(shader->prog_index,"pgm_texture2");
+        glUniform1i(shader->texture2_index, 2);
+      }
+      else
+        PGM_WARN_OBJECT (plugin->rdr, "program linking error\n");
+    }
+    return (PgmPluginShader) shader;
+}
+
+static void
+delete_shaders (PluginOpengles2 *plugin,
+                PluginOpengles2Shader *shaders,
+                guint16 count)
+{
+    guint32 i;
+    for (i = 0; i < count; i++)
+    {
+        glDetachShader(shaders[i].prog_index, shaders[i].vert_index);
+        glDetachShader(shaders[i].prog_index, shaders[i].frag_index);
+        glDeleteProgram(shaders[i].prog_index);
+        g_slice_free (PluginOpengles2Shader, &(shaders[i]));
+    }
+
+}
+
+static void
+bind_shader (PluginOpengles2 *plugin,
+             PluginOpengles2Shader *shader)
+{
+    GLint success;
+    
+    if (shader != NULL) {
+        glUseProgram(shader->prog_index);
+        glUniformMatrix4fv(plugin->shader->proj_index, 1, GL_FALSE, plugin->proj_mat);
+        glUniformMatrix4fv(plugin->shader->modelview_index, 1, GL_FALSE, plugin->modelview_mat);
+    }
+    plugin->shader = shader;
+}
+
+static void
+set_shader_uniforms (PluginOpengles2 *plugin,
+                     PgmShaderUniformData *uniforms)
+{
+  /* Not used, we have some predefined uniforms, have a look at the default shaders */
+  PGM_INFO_OBJECT(plugin->rdr, "%s: set shader uniforms\n", __func__);
+}
+
+static void
+swap_buffers (PluginOpengles2 *plugin)
+{
+    backend_swap_buffers (plugin->backend);
+}
+
+static void
+get_screen_size (PluginOpengles2 *plugin,
+                 guint32 *width,
+                 guint32 *height)
+{
+    backend_get_screen_size (plugin->backend, width, height);
+}
+
+static void
+get_screen_resolution (PluginOpengles2 *plugin,
+                       guint32 *width,
+                       guint32 *height)
+{
+    backend_get_screen_resolution (plugin->backend, width, height);
+}
+
+static void
+set_window_title (PluginOpengles2 *plugin,
+                  const gchar *title)
+{
+    backend_set_window_title (plugin->backend, title);
+}
+
+static void
+set_window_visible (PluginOpengles2 *plugin,
+                    gboolean visible)
+{
+    backend_set_window_visible (plugin->backend, visible);
+}
+
+static void
+set_window_decorated (PluginOpengles2 *plugin,
+                      gboolean decorated)
+{
+    backend_set_window_decorated (plugin->backend, decorated);
+}
+
+static void
+set_window_fullscreen (PluginOpengles2 *plugin,
+                       gboolean fullscreen)
+{
+    backend_set_window_fullscreen (plugin->backend, fullscreen);
+}
+
+static void
+set_window_iconified (PluginOpengles2 *plugin,
+                      gboolean iconified)
+{
+    backend_set_window_iconified (plugin->backend, iconified);
+}
+
+static void
+set_window_cursor (PluginOpengles2 *plugin,
+                   PgmRendererCursor cursor)
+{
+    backend_set_window_cursor (plugin->backend, cursor);
+}
+
+/* static void */
+/* set_window_icon (PluginOpengles2 *plugin, */
+/*                  GdkPixbuf *icon) */
+/* { */
+/*     backend_set_window_icon (plugin->backend, icon); */
+/* } */
+
+static void
+set_window_size (PluginOpengles2 *plugin,
+                 guint32 width,
+                 guint32 height)
+{
+    backend_set_window_size (plugin->backend, width, height);
+}
+
+static void
+set_window_message_filter (PluginOpengles2 *plugin,
+                           GList *filter)
+{
+    backend_set_window_message_filter (plugin->backend, filter);
+}
+
+static void
+window_focus (PluginOpengles2 *plugin)
+{
+    backend_window_focus (plugin->backend);
+}
+
+static guint32
+get_window_id (PluginOpengles2 *plugin)
+{
+    return backend_get_window_id (plugin->backend);
+}
+
+static void
+set_window_drag_status (PluginOpengles2 *plugin,
+                        gboolean accept)
+{
+    backend_set_window_drag_status (plugin->backend, accept);
+}
+
+/* Plugin  */
+
+static gboolean
+is_extension_supported (const gchar *extensions,
+                        const gchar *extension)
+{
+    if (extensions != NULL && extension != NULL)
+    {
+        const gsize len = strlen (extension);
+        gchar *p = (gchar*) extensions;
+        gchar *end = p + strlen (p);
+
+        while (p < end)
+        {
+            const gsize size = strcspn (p, " ");
+            if (len == size && strncmp (extension, p, size) == 0)
+                return TRUE;
+            p += size + 1;
+        }
+    }
+
+    return FALSE;
+}
+
+static gboolean
+init_plugin (PluginOpengles2 *plugin,
+             guint32 options)
+{
+    const struct {
+        const gchar *name; guint8 flag;
+    } extension_map[] = {
+        { "GL_IMG_texture_format_BGRA8888", FLAG_TEXTURE_FORMAT_BGRA8888 },
+        { NULL,                             0                            }
+    };
+    const gchar *vendor, *renderer, *version, *extensions;
+    PluginOpengles2Texture *texture;
+    PgmRendererCapabilities *caps;
+    PgmPluginFuncs *funcs;
+    guint8 extension_flags = 0;
+    guint8 caps_flags = 0;
+    guint32 i;
+
+
+    /* Get the information strings */
+    version = (const gchar*) glGetString (GL_VERSION);
+    vendor = (const gchar*) glGetString (GL_VENDOR);
+    renderer = (const gchar*) glGetString (GL_RENDERER);
+    extensions = (const gchar*) glGetString (GL_EXTENSIONS);
+    PGM_INFO_OBJECT (plugin->rdr, "OpenGL ES vendor: %s", vendor);
+    PGM_INFO_OBJECT (plugin->rdr, "OpenGL ES renderer: %s", renderer);
+    PGM_INFO_OBJECT (plugin->rdr, "OpenGL ES version: %s", version);
+    PGM_DEBUG_OBJECT (plugin->rdr, "OpenGL ES extensions: %s", extensions);
+
+    /* Store the supported extensions in a bitfield */
+    for (i = 0; extension_map[i].name != NULL; i++)
+        if (is_extension_supported (extensions, extension_map[i].name) == TRUE)
+            extension_flags |= extension_map[i].flag;
+    plugin->extension_flags = extension_flags;
+
+    /* Set initial states */
+    /* XXX: Some of these must be set from the core with dedicated functions */
+    glEnableVertexAttribArray(PGM_APOSITION);
+    glEnable (GL_BLEND);
+    glDepthFunc (GL_LEQUAL);
+    glEnable (GL_DEPTH_TEST);
+
+    glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable (GL_TEXTURE_2D);
+
+    /* Fill the default texture */
+    texture = g_slice_alloc (sizeof (PluginOpengles2Texture));
+    texture->type = GL_TEXTURE_2D;
+    texture->id = 0;
+    plugin->default_texture = texture;
+
+    /* Allocate memory for modelview/projection matrices */
+    plugin->proj_mat = (GLfloat*) malloc (16*sizeof(GLfloat));
+    plugin->modelview_mat = (GLfloat*) malloc (16*sizeof(GLfloat));
+
+    /* Fill the caps */
+    caps = pgm_renderer_capabilities_new ();
+    caps->device_vendor = g_strdup (vendor);
+    caps->device_description = g_strconcat (renderer, " (", version, ")", NULL);
+    if (backend_is_window_pluggable (plugin->backend))
+        caps_flags |= PGM_RENDERER_PLUGGABLE_WINDOW;
+    if (backend_is_window_layered (plugin->backend))
+        caps_flags |= PGM_RENDERER_LAYERED_WINDOW;
+    caps->flags = caps_flags;
+
+    /* Store supported shading languages */
+    caps->shading_languages = g_list_prepend
+            (NULL, pgm_renderer_shading_language_new ("glsles", "1.0", PGM_RENDERER_FRAGMENT_PROGRAM | PGM_RENDERER_VERTEX_PROGRAM ));    
+
+    /* Store limits */
+    glGetIntegerv (GL_MAX_TEXTURE_SIZE, &caps->max_texture_size);
+    plugin->max_texture_units = caps->max_texture_units = 3;
+    caps->max_lights = 0;
+    plugin->caps = caps;
+
+    /* Fill the funcs */
+    funcs = g_slice_alloc (sizeof (PgmPluginFuncs));
+    funcs->set_sync_to_vblank =
+        (PgmPluginSetSyncToVBlankFunc) set_sync_to_vblank;
+    funcs->wait_for_vblank = (PgmPluginWaitForVBlankFunc) wait_for_vblank;
+    funcs->clear_buffers = (PgmPluginClearBuffersFunc) clear_buffers;
+    funcs->set_clear_color = (PgmPluginSetClearColorFunc) set_clear_color;
+    funcs->set_viewport = (PgmPluginSetViewportFunc) set_viewport;
+    funcs->set_projection_matrix =
+        (PgmPluginSetProjectionMatrixFunc) set_projection_matrix;
+    funcs->set_modelview_matrix =
+        (PgmPluginSetModelviewMatrixFunc) set_modelview_matrix;
+    funcs->draw_primitive = (PgmPluginDrawPrimitiveFunc) draw_primitive;
+    funcs->create_texture = (PgmPluginCreateTextureFunc) create_texture;
+    funcs->delete_textures = (PgmPluginDeleteTexturesFunc) delete_textures;
+    funcs->bind_texture = (PgmPluginBindTextureFunc) bind_texture;
+    funcs->upload_texture = (PgmPluginUploadTextureFunc) upload_texture;
+    funcs->set_texture_states =
+        (PgmPluginSetTextureStatesFunc) set_texture_states;
+    funcs->create_shader = (PgmPluginCreateShaderFunc) create_shader;
+    funcs->delete_shaders = (PgmPluginDeleteShadersFunc) delete_shaders;
+    funcs->bind_shader = (PgmPluginBindShaderFunc) bind_shader;
+    funcs->set_shader_uniforms =
+        (PgmPluginSetShaderUniformsFunc) set_shader_uniforms;
+    funcs->swap_buffers = (PgmPluginSwapBuffersFunc) swap_buffers;
+    funcs->get_screen_size = (PgmPluginGetScreenSizeFunc) get_screen_size;
+    funcs->get_screen_resolution =
+        (PgmPluginGetScreenResolutionFunc) get_screen_resolution;
+    funcs->read_pixels = NULL;
+    funcs->set_window_title = (PgmPluginSetWindowTitleFunc) set_window_title;
+    funcs->set_window_visible =
+        (PgmPluginSetWindowVisibleFunc) set_window_visible;
+    funcs->set_window_decorated =
+        (PgmPluginSetWindowDecoratedFunc) set_window_decorated;
+    funcs->set_window_fullscreen =
+        (PgmPluginSetWindowFullscreenFunc) set_window_fullscreen;
+    funcs->set_window_iconified =
+        (PgmPluginSetWindowIconifiedFunc) set_window_iconified;
+    funcs->set_window_cursor =
+        (PgmPluginSetWindowCursorFunc) set_window_cursor;
+/*     funcs->set_window_icon = (PgmPluginSetWindowIconFunc) set_window_icon; */
+    funcs->set_window_size = (PgmPluginSetWindowSizeFunc) set_window_size;
+    funcs->set_window_message_filter =
+        (PgmPluginSetWindowMessageFilterFunc) set_window_message_filter;
+    funcs->window_focus = (PgmPluginWindowFocusFunc) window_focus;
+    funcs->get_window_id = (PgmPluginGetWindowIdFunc) get_window_id;
+    funcs->set_window_drag_status =
+        (PgmPluginSetWindowDragStatusFunc) set_window_drag_status;
+    plugin->funcs = funcs;
+
+    return TRUE;
+}
+
+static PgmPlugin
+construct (PgmRenderer *renderer,
+           GMainContext *context,
+           guint32 options,
+           PgmPluginFuncs **funcs,
+           PgmRendererCapabilities **caps,
+           PgmPluginTexture *texture,
+           PgmPluginShader *shader)
+{
+    PluginOpengles2 *plugin = g_slice_alloc0 (sizeof (PluginOpengles2));
+    Backend backend = backend_new (renderer, context, options);
+
+    if (backend != NULL)
+    {
+        plugin->rdr = renderer;
+        plugin->backend = backend;
+
+        plugin->shader = (PluginOpengles2Shader*) create_shader(plugin, "glsles", (gpointer)default_glslesvp,
+                                                                strlen(default_glslesvp), NULL, 0,
+                                                                (gpointer) default_glslesfp,
+                                                                strlen(default_glslesfp), NULL, 0);
+
+        if (init_plugin (plugin, options) == TRUE)
+        {
+            *funcs = plugin->funcs;
+            *caps = plugin->caps;
+            *texture = plugin->default_texture;
+            *shader = plugin->shader;
+            return (PgmPlugin) plugin;
+        }
+        else
+        {
+            backend_free (backend);
+            g_slice_free1 (sizeof (PluginOpengles2), plugin);
+            PGM_ERROR_OBJECT (renderer, "can't initialize OpenGL ES plugin");
+            return NULL;
+        }
+    }
+    else
+    {
+        PGM_ERROR_OBJECT (renderer, "can't create OpenGL ES context");
+        return NULL;
+    }
+}
+
+static void
+destruct (PluginOpengles2 *plugin)
+{
+    /* XXX destruct shaders? */
+    g_slice_free1 (sizeof (PgmPluginFuncs), plugin->funcs);
+    g_slice_free1 (sizeof (PluginOpengles2Texture), plugin->default_texture);
+    pgm_renderer_capabilities_free (plugin->caps);
+    backend_free (plugin->backend);
+    g_slice_free1 (sizeof (PluginOpengles2), plugin);
+}
+
+#if defined (HAVE_EGL2_NATIVE)
+#define description "a plugin based on OpenGL ES 2 (native)"
+#elif defined (HAVE_EGL2_X11)
+#define description "a plugin based on OpenGL ES 2 (X11)"
+#endif
+
+PGM_PLUGIN_DEFINE (
+    "opengles2",                        /* Name */
+    VERSION,                            /* Version */
+    description,                        /* Description */
+    "LGPL",                             /* License */
+    "https://code.fluendo.com/pigment", /* Origin */
+    "Ahmed Ammar <[e-mail]>", /* Author */
+    (PgmPluginConstructFunc) construct, /* Constructor */
+    (PgmPluginDestructFunc) destruct,   /* Destructor */
+    PGM_PLUGIN_SECONDARY                /* Rank */
+)

=== modified file 'tests/manual/test-geometry-sorting.c'
--- tests/manual/test-geometry-sorting.c	2010-05-07 16:58:25 +0000
+++ tests/manual/test-geometry-sorting.c	2010-05-19 17:34:31 +0000
@@ -447,7 +447,7 @@
     pgm_init (&argc, &argv);
 
     /* OpenGL renderer creation */
-    renderer = pgm_renderer_factory_make ("opengl", 1);
+    renderer = pgm_renderer_factory_make_auto ();
     if (!renderer)
     {
         g_print ("Cannot create a renderer\n");

=== modified file 'tests/manual/test-gst-image.c'
--- tests/manual/test-gst-image.c	2010-05-07 16:46:26 +0000
+++ tests/manual/test-gst-image.c	2010-05-19 17:34:31 +0000
@@ -78,7 +78,7 @@
     pgm_init (&argc, &argv);
     gst_init (&argc, &argv);
 
-    renderer = pgm_renderer_factory_make ("opengl", 0);
+    renderer = pgm_renderer_factory_make_auto ();
     if (!renderer)
     {
         g_print ("Cannot create the OpenGL renderer\n");