2007-04-28 Matthew Allum <mallum@openedhand.com>

* clutter/Makefile.am:
        * clutter/clutter-debug.h:
        * clutter/clutter-fixed.h:
        * clutter/clutter-main.c:
        * clutter/cogl/gles/Makefile.am:
        * clutter/cogl/gles/cogl-defines.h:
        * clutter/cogl/gles/cogl.c:
        * clutter/egl/clutter-backend-egl.c:
        * clutter/egl/clutter-backend-egl.h:
        * clutter/egl/clutter-stage-egl.c:
        * configure.ac:
        Populate most stubs for cogl GL/ES implementation.
        (against vincent - see http://svn.o-hand.com/repos/misc/ogles)
        Add various fixups to EGL backend.
        Code builds and runs (on 16bpp) but yet displays much (is close!)

        * clutter/pango/pangoclutter-render.c:
        comment out some rouge glBegin/end calls.

ChangeLog

@@ -1,3 +1,24 @@
+2007-04-28  Matthew Allum  <mallum@openedhand.com>
+
+	* clutter/Makefile.am:
+	* clutter/clutter-debug.h:
+	* clutter/clutter-fixed.h:
+	* clutter/clutter-main.c:
+	* clutter/cogl/gles/Makefile.am:
+	* clutter/cogl/gles/cogl-defines.h:
+	* clutter/cogl/gles/cogl.c:
+	* clutter/egl/clutter-backend-egl.c:
+	* clutter/egl/clutter-backend-egl.h:
+	* clutter/egl/clutter-stage-egl.c:
+	* configure.ac:
+	Populate most stubs for cogl GL/ES implementation.
+	(against vincent - see http://svn.o-hand.com/repos/misc/ogles)
+	Add various fixups to EGL backend.
+	Code builds and runs (on 16bpp) but yet displays much (is close!)
+
+	* clutter/pango/pangoclutter-render.c:
+	comment out some rouge glBegin/end calls.	
+
 2007-04-27  Matthew Allum  <mallum@openedhand.com>
 
 	* clutter/Makefile.am:

clutter/Makefile.am

@@ -158,7 +158,7 @@ source_h_priv = \
 libclutter_@CLUTTER_FLAVOUR@_@CLUTTER_API_VERSION@_la_LIBADD =   \
   $(CLUTTER_LIBS) pango/libpangoclutter.la                       \
   @CLUTTER_FLAVOUR@/libclutter-@CLUTTER_FLAVOUR@.la              \
-  cogl/gl/libclutter-cogl.la	  
+  cogl/@CLUTTER_COGL@/libclutter-cogl.la	  
 
 libclutter_@CLUTTER_FLAVOUR@_@CLUTTER_API_VERSION@_la_SOURCES =  \
   $(source_c) $(source_h) $(source_h_priv)                      

clutter/clutter-debug.h

@@ -14,7 +14,8 @@ typedef enum {
   CLUTTER_DEBUG_GL              = 1 << 5,
   CLUTTER_DEBUG_ALPHA           = 1 << 6,
   CLUTTER_DEBUG_BEHAVIOUR       = 1 << 7,
-  CLUTTER_DEBUG_PANGO           = 1 << 8
+  CLUTTER_DEBUG_PANGO           = 1 << 8,
+  CLUTTER_DEBUG_BACKEND         = 1 << 9
 } ClutterDebugFlag;
 
 #ifdef CLUTTER_ENABLE_DEBUG

clutter/clutter-fixed.h

@@ -48,6 +48,7 @@ typedef gint32 ClutterAngle;    /* angle such that 1024 == 2*PI */
 
 #define CFX_Q      16		/* Decimal part size in bits */
 #define CFX_ONE    (1 << CFX_Q)	/* 1 */
+#define CFX_HALF   32768
 #define CFX_MAX    0x7fffffff
 #define CFX_MIN    0x80000000
 

clutter/clutter-main.c

@@ -66,6 +66,7 @@ static const GDebugKey clutter_debug_keys[] = {
   { "alpha", CLUTTER_DEBUG_ALPHA },
   { "behaviour", CLUTTER_DEBUG_BEHAVIOUR },
   { "pango", CLUTTER_DEBUG_PANGO },
+  { "backend", CLUTTER_DEBUG_BACKEND },
 };
 #endif /* CLUTTER_ENABLE_DEBUG */
 
@@ -614,13 +615,17 @@ clutter_init (int    *argc,
   g_type_init ();
 
   if (clutter_parse_args (argc, argv) == FALSE)
-    return CLUTTER_INIT_ERROR_INTERNAL;
+    {
+      CLUTTER_NOTE (MISC, "failed to parse arguments.");
+      return CLUTTER_INIT_ERROR_INTERNAL;
+    }
 
   context = clutter_context_get_default ();
 
   stage_error = NULL;
   if (!_clutter_backend_init_stage (context->backend, &stage_error))
     {
+      CLUTTER_NOTE (MISC, "stage failed to initialise.");
       g_critical (stage_error->message);
       g_error_free (stage_error);
       return CLUTTER_INIT_ERROR_INTERNAL;

clutter/cogl/gles/Makefile.am

@@ -13,6 +13,7 @@ LDADD = $(CLUTTER_LIBS)
 
 noinst_LTLIBRARIES = libclutter-cogl.la
 
-libclutter_cogl_la_SOURCES =               \
+libclutter_cogl_la_SOURCES =                         \
-	$(top_srcdir)/clutter/cogl/cogl.h  \
+	$(top_srcdir)/clutter/cogl/cogl.h            \
+        $(top_srcdir)/clutter/cogl/gl/cogl-defines.h \
 	cogl.c

clutter/cogl/gles/cogl-defines.h

@@ -23,6 +23,8 @@
  * Boston, MA 02111-1307, USA.
  */
 
+#include <GLES/gl.h>
+
 #ifndef __COGL_DEFINES_H__
 #define __COGL_DEFINES_H__
 
@@ -435,6 +437,15 @@ G_BEGIN_DECLS
 #define CGL_WEIGHT_ARRAY_BUFFER_BINDING_OES GL_WEIGHT_ARRAY_BUFFER_BINDING_OES
 #define CGL_TEXTURE_CROP_RECT_OES GL_TEXTURE_CROP_RECT_OES
 
+typedef GLenum COGLenum;
+typedef GLint  COGLint;
+
+/* extras */
+
+#define CGL_TEXTURE_2D GL_TEXTURE_2D
+#define CGL_ARGB GL_ARGB
+#define CGL_TEXTURE_RECTANGLE_ARB 0 /* Its unlikely we support this */
+
 G_END_DECLS
 
 #endif

clutter/cogl/gles/cogl.c

@@ -23,9 +23,19 @@
  * Boston, MA 02111-1307, USA.
  */
 
+#include "config.h"
 #include "cogl.h"
-#include <GLES/gl.h>
 
+#include <GLES/gl.h>
+#include <string.h>
+
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+#define PIXEL_TYPE GL_UNSIGNED_BYTE
+#else
+#define PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
+#endif
+
+static gulong __enable_flags = 0;
 
 #if COGL_DEBUG
 struct token_string
@@ -97,6 +107,10 @@ cogl_paint_init (ClutterColor *color)
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
   glDisable (GL_LIGHTING); 
   glDisable (GL_DEPTH_TEST);
+
+  cogl_enable (CGL_ENABLE_BLEND);
+
+  glTexEnvx (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 }
 
 /* FIXME: inline most of these  */
@@ -113,7 +127,7 @@ cogl_pop_matrix (void)
 }
 
 void
-cogl_scaled (ClutterFixed x, ClutterFixed y)
+cogl_scale (ClutterFixed x, ClutterFixed y)
 {
   GE( glScalex (x, y, CFX_ONE) );
 }
@@ -144,8 +158,346 @@ cogl_rotatex (ClutterFixed angle,
 void
 cogl_rotate (gint angle, gint x, gint y, gint z)
 {
-  GE( glRotatef (CLUTTER_INT_TO_FIXED(angle),
+  GE( glRotatex (CLUTTER_INT_TO_FIXED(angle),
 		 CLUTTER_INT_TO_FIXED(x), 
 		 CLUTTER_INT_TO_FIXED(y), 
 		 CLUTTER_INT_TO_FIXED(z)) );
 }
+
+void
+cogl_enable (gulong flags)
+{
+  /* This function essentially caches glEnable state() in the
+   * hope of lessening number GL traffic.
+  */
+  if (flags & CGL_ENABLE_BLEND)
+    {
+      if (!(__enable_flags & CGL_ENABLE_BLEND))
+	{
+	  glEnable (GL_BLEND);
+	  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+      __enable_flags |= CGL_ENABLE_BLEND;
+    }
+  else if (__enable_flags & CGL_ENABLE_BLEND)
+    {
+      glDisable (GL_BLEND);
+      __enable_flags &= ~CGL_ENABLE_BLEND;
+    }
+
+  if (flags & CGL_ENABLE_TEXTURE_2D)
+    {
+      if (!(__enable_flags & CGL_ENABLE_TEXTURE_2D))
+	glEnable (GL_TEXTURE_2D);
+      __enable_flags |= CGL_ENABLE_TEXTURE_2D;
+    }
+  else if (__enable_flags & CGL_ENABLE_TEXTURE_2D)
+    {
+      glDisable (GL_TEXTURE_2D);
+      __enable_flags &= ~CGL_ENABLE_TEXTURE_2D;
+    }
+
+#if 0
+  if (flags & CGL_ENABLE_TEXTURE_RECT)
+    {
+      if (!(__enable_flags & CGL_ENABLE_TEXTURE_RECT))
+	  glEnable (GL_TEXTURE_RECTANGLE_ARB);
+
+      __enable_flags |= CGL_ENABLE_TEXTURE_RECT;
+    }
+  else if (__enable_flags & CGL_ENABLE_TEXTURE_RECT)
+    {
+      glDisable (GL_TEXTURE_RECTANGLE_ARB);
+      __enable_flags &= ~CGL_ENABLE_TEXTURE_RECT;
+    }
+#endif
+
+  if (flags & CGL_ENABLE_ALPHA_TEST)
+    {
+      if (!(__enable_flags & CGL_ENABLE_ALPHA_TEST))
+	glEnable (GL_ALPHA_TEST);
+
+      __enable_flags |= CGL_ENABLE_ALPHA_TEST;
+    }
+  else if (__enable_flags & CGL_ENABLE_ALPHA_TEST)
+    {
+      glDisable (GL_ALPHA_TEST);
+      __enable_flags &= ~CGL_ENABLE_ALPHA_TEST;
+    }
+}
+
+void
+cogl_color (ClutterColor *color)
+{
+#define FIX(x) CFX_DIV(CLUTTER_INT_TO_FIXED(x), CFX_255)
+
+  GE( glColor4x (FIX(color->red), 
+		 FIX(color->green), 
+		 FIX(color->blue), 
+		 FIX(color->alpha)) );  
+#undef FIX
+}
+
+gboolean
+cogl_texture_can_size (COGLenum pixel_format,
+		       COGLenum pixel_type,
+		       int    width, 
+		       int    height)
+{
+  GLint new_width = 0;
+
+  /* FIXME */
+  return TRUE;
+
+#if 0
+  GE( glTexImage2D (GL_PROXY_TEXTURE_2D, 0, GL_RGBA,
+		    width, height, 0 /* border */,
+		    pixel_format, pixel_type, NULL) );
+
+  GE( glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0,
+				GL_TEXTURE_WIDTH, &new_width) );
+
+  return new_width != 0;
+#endif
+}
+
+void
+cogl_texture_quad (gint   x1,
+		   gint   x2, 
+		   gint   y1, 
+		   gint   y2,
+		   ClutterFixed tx1,
+		   ClutterFixed ty1,
+		   ClutterFixed tx2,
+		   ClutterFixed ty2)
+{
+  GLfixed quadVerts[] = {
+    x1, y1, 0,
+    x2, y1, 0,
+    x2, y2, 0,
+    x2, y2, 0,
+    x1, y2, 0,
+    x1, y1, 0
+  };
+
+  GLfixed quadTex[] = {
+    tx1, ty1,
+    tx2, ty1,
+    tx2, ty2,
+    tx2, ty2,
+    tx1, ty2,
+    tx1, ty1
+  };
+
+  glEnableClientState(GL_VERTEX_ARRAY);
+  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+  glVertexPointer(3, GL_FIXED, 0, quadVerts);
+  glTexCoordPointer(2, GL_FIXED, 0, quadTex);
+  
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+
+  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+  glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void
+cogl_textures_create (guint num, guint *textures)
+{
+  GE( glGenTextures (num, textures) );
+}
+
+void
+cogl_textures_destroy (guint num, const guint *textures)
+{
+  GE( glDeleteTextures (num, textures) );
+}
+
+void
+cogl_texture_bind (COGLenum target, guint texture)
+{
+  GE( glBindTexture (target, texture) );
+}
+
+void
+cogl_texture_set_alignment (COGLenum target, 
+			    guint    alignment,
+			    guint    row_length)
+{
+  /* GE( glPixelStorei (GL_UNPACK_ROW_LENGTH, row_length) ); */
+  GE( glPixelStorei (GL_UNPACK_ALIGNMENT, alignment) );
+}
+
+void
+cogl_texture_set_filters (COGLenum target, 
+			  COGLenum min_filter,
+			  COGLenum max_filter)
+{
+  GE( glTexParameteri(target, GL_TEXTURE_MAG_FILTER, max_filter) );
+  GE( glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter) );
+}
+
+void
+cogl_texture_set_wrap (COGLenum target, 
+		       COGLenum wrap_s,
+		       COGLenum wrap_t)
+{
+  GE( glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap_s) );
+  GE( glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap_s) );
+}
+
+void
+cogl_texture_image_2d (COGLenum      target,
+		       COGLint       internal_format,
+		       gint          width, 
+		       gint          height, 
+		       COGLenum      format,
+		       COGLenum      type,
+		       const guchar* pixels)
+{
+  GE( glTexImage2D (target,
+		    0, 		/* No mipmap support as yet */
+		    internal_format,
+		    width,
+		    height,
+		    0, 		/* 0 pixel border */
+		    format,
+		    type,
+		    pixels) );
+}
+
+void
+cogl_texture_sub_image_2d (COGLenum      target,
+			   gint          xoff,
+			   gint          yoff,
+			   gint          width, 
+			   gint          height,
+			   COGLenum      format, 
+			   COGLenum      type,
+			   const guchar* pixels)
+{
+  GE( glTexSubImage2D (target,
+		       0,
+		       xoff,
+		       yoff,
+		       width,
+		       height,
+		       format,
+		       type,
+		       pixels));
+}
+
+void
+cogl_rectangle (gint x, gint y, guint width, guint height)
+{
+#define FIX CLUTTER_INT_TO_FIXED
+
+  GLfixed rect_verts[] = {
+    FIX(x), FIX(y), 
+    FIX(x + width), FIX(y), 
+    FIX(x), FIX(y + height), 
+    FIX(x + width), FIX(y + height), 
+  };
+
+#undef FIX
+
+  GE( glVertexPointer(2, GL_FIXED, 0, rect_verts) );
+  GE( glEnableClientState(GL_VERTEX_ARRAY) );
+  GE( glDrawArrays(GL_TRIANGLE_STRIP, 0, 4) );
+  GE( glDisableClientState(GL_VERTEX_ARRAY) );
+}
+
+/* FIXME: Should use ClutterReal or Fixed */
+void
+cogl_trapezoid (gint y1,
+		gint x11,
+		gint x21,
+		gint y2,
+		gint x12,
+		gint x22)
+{
+  /* FIXME */
+}
+
+
+void
+cogl_alpha_func (COGLenum     func, 
+		 ClutterFixed ref)
+{
+  GE( glAlphaFunc (func, CLUTTER_FIXED_TO_FLOAT(ref)) );
+}
+
+/*
+ * Fixed point implementation of the perspective function
+ */
+void
+cogl_perspective (ClutterAngle fovy,
+		  ClutterFixed aspect,
+		  ClutterFixed zNear,
+		  ClutterFixed zFar)
+{
+  ClutterFixed xmax, ymax;
+  ClutterFixed x, y, c, d;
+
+  GLfixed m[16];
+  
+  memset (&m[0], 0, sizeof (m));
+
+  /*
+   * Based on the original algorithm in perspective():
+   * 
+   * 1) xmin = -xmax => xmax + xmin == 0 && xmax - xmin == 2 * xmax
+   * same true for y, hence: a == 0 && b == 0;
+   *
+   * 2) When working with small numbers, we can are loosing significant
+   * precision, hence we use clutter_qmulx() here, not the fast macro.
+   */
+  ymax = clutter_qmulx (zNear, clutter_tani (fovy >> 1));
+  xmax = clutter_qmulx (ymax, aspect);
+
+  x = CFX_DIV (zNear, xmax);
+  y = CFX_DIV (zNear, ymax);
+  c = CFX_DIV (-(zFar + zNear), ( zFar - zNear));
+  d = CFX_DIV (-(clutter_qmulx (2*zFar, zNear)), (zFar - zNear));
+
+#define M(row,col)  m[col*4+row]
+  M(0,0) = x;
+  M(1,1) = y;
+  M(2,2) = c;
+  M(2,3) = d;
+  M(3,2) = 1 + ~CFX_ONE;
+  
+  GE( glMultMatrixx (m) );
+#undef M
+}
+
+void
+cogl_setup_viewport (guint        width,
+		     guint        height,
+		     ClutterAngle fovy,
+		     ClutterFixed aspect,
+		     ClutterFixed z_near,
+		     ClutterFixed z_far)
+{
+  GE( glViewport (0, 0, width, height) );
+  
+  GE( glMatrixMode (GL_PROJECTION) );
+  GE( glLoadIdentity () );
+
+  cogl_perspective (fovy, aspect, z_near, z_far);
+  
+  GE( glMatrixMode (GL_MODELVIEW) );
+  GE( glLoadIdentity () );
+
+  /* camera distance from screen, 0.5 * tan (FOV) */
+#define DEFAULT_Z_CAMERA 0.866025404f
+
+  GE( glTranslatex (-CFX_HALF, 
+		    -CFX_HALF, 
+		    -CLUTTER_FLOAT_TO_FIXED(DEFAULT_Z_CAMERA)) );
+
+  GE( glScalex ( CFX_DIV(CFX_ONE, CLUTTER_INT_TO_FIXED(width)),
+		-CFX_DIV(CFX_ONE, CLUTTER_INT_TO_FIXED(height)),
+		 CFX_DIV(CFX_ONE, CLUTTER_INT_TO_FIXED(width))) );
+
+  GE( glTranslatex (0, -CFX_DIV(CFX_ONE, CLUTTER_INT_TO_FIXED(height)), 0) );
+}

clutter/egl/clutter-backend-egl.c

@@ -59,6 +59,8 @@ clutter_backend_egl_post_parse (ClutterBackend  *backend,
 
   if (backend_egl->xdpy)
     {
+      EGLBoolean status;
+
       CLUTTER_NOTE (MISC, "Getting the X screen");
 
       if (clutter_screen == 0)
@@ -73,23 +75,41 @@ clutter_backend_egl_post_parse (ClutterBackend  *backend,
       
       backend_egl->display_name = g_strdup (clutter_display_name);
 
+      backend_egl->edpy = eglGetDisplay(backend_egl->xdpy);
+
+      status = eglInitialize(backend_egl->edpy, 
+			     &backend_egl->egl_version_major, 
+			     &backend_egl->egl_version_minor);
+
+      if (status != EGL_TRUE)
+	{
+	  g_set_error (error, CLUTTER_INIT_ERROR,
+		       CLUTTER_INIT_ERROR_BACKEND,
+		       "Unable to Initialize EGL");
+	  return FALSE;
+	}
+
       /* generic backend properties */
       backend->res_width = WidthOfScreen (backend_egl->xscreen);
       backend->res_height = HeightOfScreen (backend_egl->xscreen);
       backend->mm_width = WidthMMOfScreen (backend_egl->xscreen);
       backend->mm_height = HeightMMOfScreen (backend_egl->xscreen);
       backend->screen_num = backend_egl->xscreen_num;
-      backend->n_screens = ScreenCount (backend_egl->xdpy)
+      backend->n_screens = ScreenCount (backend_egl->xdpy);
     }
 
   g_free (clutter_display_name);
   
-  CLUTTER_NOTE (MISC, "X Display `%s' [%p] opened (screen:%d, root:%u)",
+  CLUTTER_NOTE (BACKEND, "X Display `%s' [%p] opened (screen:%d, root:%u)",
                 backend_egl->display_name,
                 backend_egl->xdpy,
                 backend_egl->xscreen_num,
                 (unsigned int) backend_egl->xwin_root);
 
+  CLUTTER_NOTE (BACKEND, "EGL Reports version %i.%i",
+		backend_egl->egl_version_major, 
+		backend_egl->egl_version_minor);
+
   return TRUE;
 }
 
@@ -164,7 +184,9 @@ clutter_backend_egl_add_options (ClutterBackend *backend,
 static ClutterActor *
 clutter_backend_egl_get_stage (ClutterBackend *backend)
 {
-  return NULL;
+  ClutterBackendEgl *backend_egl = CLUTTER_BACKEND_EGL (backend);
+
+  return backend_egl->stage;
 }
 
 static void
@@ -245,6 +267,7 @@ static void
 clutter_backend_egl_init (ClutterBackendEgl *backend_egl)
 {
   ClutterBackend *backend = CLUTTER_BACKEND (backend_egl);
+
   backend->events_queue = g_queue_new ();
 
   backend->button_click_time[0] = backend->button_click_time[1] = 0;
@@ -258,7 +281,7 @@ clutter_backend_egl_init (ClutterBackendEgl *backend_egl)
   backend->n_screens = 0;
 
   backend->double_click_time = 250;
-  backend->double_click_distance = 5
+  backend->double_click_distance = 5;
 }
 
 GType

clutter/egl/clutter-backend-egl.h

@@ -27,6 +27,9 @@
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
+#include <GLES/gl.h>
+#include <GLES/egl.h>
+
 G_BEGIN_DECLS
 
 #define CLUTTER_TYPE_BACKEND_EGL                (clutter_backend_egl_get_type ())
@@ -49,6 +52,10 @@ struct _ClutterBackendEgl
   int      xscreen_num;
   Screen  *xscreen;
 
+  /* EGL Specific */
+  EGLDisplay edpy;
+  gint       egl_version_major, egl_version_minor;
+
   /* main stage singleton */
   ClutterActor *stage;
 

clutter/egl/clutter-stage-egl.c

@@ -91,7 +91,7 @@ clutter_stage_egl_realize (ClutterActor *actor)
 
   gboolean is_offscreen;
 
-  CLUTTER_NOTE (MISC, "Realizing main stage");
+  CLUTTER_NOTE (BACKEND, "Realizing main stage");
 
   g_object_get (actor, "offscreen", &is_offscreen, NULL);
 
@@ -117,15 +117,20 @@ clutter_stage_egl_realize (ClutterActor *actor)
 				sizeof configs / sizeof configs[0], 
 				&config_count);
 
+      if (status != EGL_TRUE)
+	g_warning ("eglChooseConfig");		
+      
       if (stage_egl->xwin == None)
-	stage_egl->xwin = XCreateSimpleWindow(clutter_egl_get_default_display(),
+	stage_egl->xwin 
-					    clutter_egl_get_default_root_window(),
+	  = XCreateSimpleWindow(clutter_egl_get_default_display(),
-					    0, 0,
+				clutter_egl_get_default_root_window(),
-					    stage_egl->xwin_width, 
+				0, 0,
-					    stage_egl->xwin_height,
+				stage_egl->xwin_width, 
-					    0, 0, 
+				stage_egl->xwin_height,
-					    WhitePixel(clutter_egl_get_default_display(), 
+				0, 0, 
-						       clutter_egl_get_default_screen()));
+				WhitePixel(clutter_egl_get_default_display(), 
+					   clutter_egl_get_default_screen()));
+
       XSelectInput(clutter_egl_get_default_display(), 
 		   stage_egl->xwin, 
 		   StructureNotifyMask
@@ -149,6 +154,7 @@ clutter_stage_egl_realize (ClutterActor *actor)
 				  configs[0], 
 				  (NativeWindowType)stage_egl->xwin, 
 				  NULL);
+
       if (stage_egl->egl_surface == EGL_NO_SURFACE)
 	g_warning ("eglCreateWindowSurface");
       
@@ -168,6 +174,7 @@ clutter_stage_egl_realize (ClutterActor *actor)
       if (status != EGL_TRUE)
 	g_warning ("eglMakeCurrent");		
 
+      
     }
   else
     {
@@ -196,15 +203,7 @@ clutter_stage_egl_paint (ClutterActor *self)
 
   clutter_stage_get_color (stage, &stage_color);
 
-  /* FIXME: move below into cogl_paint_start() ? */
+  cogl_paint_init (&stage_color);
-  glClearColorx ((stage_color.red << 16) / 0xff, 
-		 (stage_color.green << 16) / 0xff,
-		 (stage_color.blue << 16) / 0xff, 
-		 0xff);
-
-  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-  glDisable (GL_LIGHTING); 
-  glDisable (GL_DEPTH_TEST);
 
   /* Basically call up to ClutterGroup paint here */
   CLUTTER_ACTOR_CLASS (clutter_stage_egl_parent_class)->paint (self);
@@ -215,8 +214,7 @@ clutter_stage_egl_paint (ClutterActor *self)
   if (stage_egl->xwin)
     {
       clutter_feature_wait_for_vblank ();
-      eglSwapBuffers ((EGLDisplay)stage_egl->xdpy, 
+      eglSwapBuffers ((EGLDisplay)stage_egl->xdpy,  stage_egl->egl_surface);
-		      (EGLSurface)stage_egl->xwin);
     }
   else
     {

clutter/pango/pangoclutter-render.c

@@ -339,8 +339,10 @@ draw_glyph (PangoRenderer *renderer_,
           _pango_clutter_font_set_cache_glyph_data (font, glyph, g);
         }
 
+      /*
       if (renderer->curtex)
         glEnd ();
+      */
 
       tc_get (&g->tex, bm.width, bm.height);
 
@@ -364,7 +366,7 @@ draw_glyph (PangoRenderer *renderer_,
 				 bm.bitmap);
 
       renderer->curtex = g->tex.name;
-      glBegin (GL_QUADS);
+      /* glBegin (GL_QUADS); */
     }
   else CLUTTER_NOTE (PANGO, g_message ("cache succsess %i\n", glyph));
 

configure.ac

@@ -130,7 +130,7 @@ case $clutterbackend in
     AC_DEFINE([HAVE_CLUTTER_EGL], 1, [Have the EGL backend])
 
     # We currently assume having egl means also having gles..
-    CLUTTER_GOGL="gles"
+    CLUTTER_COGL="gles"
     AC_DEFINE([HAVE_COGL_GLES], 1, [Have GL/ES for rendering])
 
     PKG_CHECK_MODULES(EGL, libvincent, HAVE_OGLES=yes, HAVE_OGLES=no)