From e0243443ccb12eb1a9f62d9b4258bb111551998c Mon Sep 17 00:00:00 2001

From: "Owen W. Taylor" <otaylor@fishsoup.net>

Date: Sat, 26 Apr 2014 16:38:58 -0400

Subject: [PATCH 6/8] CoglTexturePixmapX11: add support for stereo content

Add cogl_texture_pixmap_x11_new_left() and

cogl_texture_pixmap_x11_new_right() (which takes the left texture

as an argument) for texture pixmap rendering with stereo content.

The underlying GLXPixmap is created using a stereo visual and shared

between the left and right textures.

---

 cogl/cogl-glx-display-private.h               |   3 +-

 cogl/winsys/cogl-texture-pixmap-x11-private.h |  18 ++++

 cogl/winsys/cogl-texture-pixmap-x11.c         |  92 +++++++++++++++++++--

 cogl/winsys/cogl-texture-pixmap-x11.h         |  56 +++++++++++++

 cogl/winsys/cogl-winsys-egl-x11.c             |   4 +-

 cogl/winsys/cogl-winsys-glx.c                 | 113 ++++++++++++++++++--------

 cogl/winsys/cogl-winsys-private.h             |   4 +-

 7 files changed, 246 insertions(+), 44 deletions(-)

diff --git a/cogl/cogl-glx-display-private.h b/cogl/cogl-glx-display-private.h

index 69b1570..9f7ad47 100644

--- a/cogl/cogl-glx-display-private.h

+++ b/cogl/cogl-glx-display-private.h

@@ -33,10 +33,11 @@ typedef struct _CoglGLXCachedConfig

   int depth;

   CoglBool found;

   GLXFBConfig fb_config;

+  CoglBool stereo;

   CoglBool can_mipmap;

 } CoglGLXCachedConfig;

-#define COGL_GLX_N_CACHED_CONFIGS 3

+#define COGL_GLX_N_CACHED_CONFIGS 6

 typedef struct _CoglGLXDisplay

 {

diff --git a/cogl/winsys/cogl-texture-pixmap-x11-private.h b/cogl/winsys/cogl-texture-pixmap-x11-private.h

index b99dfa6..ce79bd3 100644

--- a/cogl/winsys/cogl-texture-pixmap-x11-private.h

+++ b/cogl/winsys/cogl-texture-pixmap-x11-private.h

@@ -48,10 +48,27 @@ struct _CoglDamageRectangle

   unsigned int y2;

 };

+/* For stereo, there are a pair of textures, but we want to share most

+ * other state (the GLXPixmap, visual, etc.) The way we do this is that

+ * the left-eye texture has all the state (there is in fact, no internal

+ * difference between the a MONO and a LEFT texture ), and the

+ * right-eye texture simply points to the left eye texture, with all

+ * other fields ignored.

+ */

+typedef enum

+{

+  COGL_TEXTURE_PIXMAP_MONO,

+  COGL_TEXTURE_PIXMAP_LEFT,

+  COGL_TEXTURE_PIXMAP_RIGHT

+} CoglTexturePixmapStereoMode;

+

 struct _CoglTexturePixmapX11

 {

   CoglTexture _parent;

+  CoglTexturePixmapStereoMode stereo_mode;

+  CoglTexturePixmapX11 *left; /* Set only if stereo_mode=RIGHT */

+

   Pixmap pixmap;

   CoglTexture *tex;

@@ -75,4 +92,5 @@ struct _CoglTexturePixmapX11

   CoglBool use_winsys_texture;

 };

+

 #endif /* __COGL_TEXTURE_PIXMAP_X11_PRIVATE_H */

diff --git a/cogl/winsys/cogl-texture-pixmap-x11.c b/cogl/winsys/cogl-texture-pixmap-x11.c

index 71d00ea..baf27e1 100644

--- a/cogl/winsys/cogl-texture-pixmap-x11.c

+++ b/cogl/winsys/cogl-texture-pixmap-x11.c

@@ -274,11 +274,12 @@ set_damage_object_internal (CoglContext *ctx,

                                    tex_pixmap);

 }

-CoglTexturePixmapX11 *

-cogl_texture_pixmap_x11_new (CoglContext *ctxt,

-                             uint32_t pixmap,

-                             CoglBool automatic_updates,

-                             CoglError **error)

+static CoglTexturePixmapX11 *

+_cogl_texture_pixmap_x11_new (CoglContext *ctxt,

+                              uint32_t pixmap,

+                              CoglBool automatic_updates,

+                              CoglTexturePixmapStereoMode stereo_mode,

+                              CoglError **error)

 {

   CoglTexturePixmapX11 *tex_pixmap = g_new (CoglTexturePixmapX11, 1);

   Display *display = cogl_xlib_renderer_get_display (ctxt->display->renderer);

@@ -308,6 +309,8 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,

                       &cogl_texture_pixmap_x11_vtable);

   tex_pixmap->pixmap = pixmap;

+  tex_pixmap->stereo_mode = stereo_mode;

+  tex_pixmap->left = NULL;

   tex_pixmap->image = NULL;

   tex_pixmap->shm_info.shmid = -1;

   tex_pixmap->tex = NULL;

@@ -366,6 +369,52 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,

   return _cogl_texture_pixmap_x11_object_new (tex_pixmap);

 }

+CoglTexturePixmapX11 *

+cogl_texture_pixmap_x11_new (CoglContext *ctxt,

+                             uint32_t pixmap,

+                             CoglBool automatic_updates,

+                             CoglError **error)

+

+{

+  return _cogl_texture_pixmap_x11_new (ctxt, pixmap,

+                                       automatic_updates, COGL_TEXTURE_PIXMAP_MONO,

+                                       error);

+}

+

+CoglTexturePixmapX11 *

+cogl_texture_pixmap_x11_new_left (CoglContext *ctxt,

+                                  uint32_t pixmap,

+                                  CoglBool automatic_updates,

+                                  CoglError **error)

+{

+  return _cogl_texture_pixmap_x11_new (ctxt, pixmap,

+                                       automatic_updates, COGL_TEXTURE_PIXMAP_LEFT,

+                                       error);

+}

+

+CoglTexturePixmapX11 *

+cogl_texture_pixmap_x11_new_right (CoglTexturePixmapX11 *tfp_left)

+{

+  CoglTexture *texture_left = COGL_TEXTURE (tfp_left);

+  CoglTexturePixmapX11 *tfp_right;

+

+  g_return_val_if_fail (tfp_left->stereo_mode == COGL_TEXTURE_PIXMAP_LEFT, NULL);

+

+  tfp_right = g_new0 (CoglTexturePixmapX11, 1);

+  tfp_right->stereo_mode = COGL_TEXTURE_PIXMAP_RIGHT;

+  tfp_right->left = cogl_object_ref (tfp_left);

+

+  _cogl_texture_init (COGL_TEXTURE (tfp_right),

+		      texture_left->context,

+		      texture_left->width,

+		      texture_left->height,

+		      &cogl_texture_pixmap_x11_vtable);

+

+  _cogl_texture_set_allocated (COGL_TEXTURE (tfp_right), TRUE);

+

+  return _cogl_texture_pixmap_x11_object_new (tfp_right);

+}

+

 static CoglBool

 _cogl_texture_pixmap_x11_allocate (CoglTexture *tex,

                                    CoglError **error)

@@ -457,6 +506,9 @@ cogl_texture_pixmap_x11_update_area (CoglTexturePixmapX11 *tex_pixmap,

      texture because we can't determine which will be needed until we

      actually render something */

+  if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    tex_pixmap = tex_pixmap->left;

+

   if (tex_pixmap->winsys)

     {

       const CoglWinsysVtable *winsys;

@@ -471,6 +523,9 @@ cogl_texture_pixmap_x11_update_area (CoglTexturePixmapX11 *tex_pixmap,

 CoglBool

 cogl_texture_pixmap_x11_is_using_tfp_extension (CoglTexturePixmapX11 *tex_pixmap)

 {

+  if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    tex_pixmap = tex_pixmap->left;

+

   return !!tex_pixmap->winsys;

 }

@@ -484,6 +539,8 @@ cogl_texture_pixmap_x11_set_damage_object (CoglTexturePixmapX11 *tex_pixmap,

   _COGL_GET_CONTEXT (ctxt, NO_RETVAL);

+  g_return_if_fail (tex_pixmap->stereo_mode != COGL_TEXTURE_PIXMAP_RIGHT);

+

   damage_base = _cogl_xlib_get_damage_base ();

   if (damage_base >= 0)

     set_damage_object_internal (ctxt, tex_pixmap, damage, report_level);

@@ -648,12 +705,16 @@ static void

 _cogl_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

                                  CoglBool needs_mipmap)

 {

+  CoglTexturePixmapStereoMode stereo_mode = tex_pixmap->stereo_mode;

+  if (stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    tex_pixmap = tex_pixmap->left;

+

   if (tex_pixmap->winsys)

     {

       const CoglWinsysVtable *winsys =

         _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);

-      if (winsys->texture_pixmap_x11_update (tex_pixmap, needs_mipmap))

+      if (winsys->texture_pixmap_x11_update (tex_pixmap, stereo_mode, needs_mipmap))

         {

           _cogl_texture_pixmap_x11_set_use_winsys_texture (tex_pixmap, TRUE);

           return;

@@ -670,8 +731,13 @@ _cogl_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

 static CoglTexture *

 _cogl_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)

 {

+  CoglTexturePixmapX11 *original_pixmap = tex_pixmap;

   CoglTexture *tex;

   int i;

+  CoglTexturePixmapStereoMode stereo_mode = tex_pixmap->stereo_mode;

+

+  if (stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    tex_pixmap = tex_pixmap->left;

   /* We try getting the texture twice, once without flushing the

      updates and once with. If pre_paint has been called already then

@@ -688,7 +754,7 @@ _cogl_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)

         {

           const CoglWinsysVtable *winsys =

             _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);

-          tex = winsys->texture_pixmap_x11_get_texture (tex_pixmap);

+          tex = winsys->texture_pixmap_x11_get_texture (tex_pixmap, stereo_mode);

         }

       else

         tex = tex_pixmap->tex;

@@ -696,7 +762,7 @@ _cogl_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)

       if (tex)

         return tex;

-      _cogl_texture_pixmap_x11_update (tex_pixmap, FALSE);

+      _cogl_texture_pixmap_x11_update (original_pixmap, FALSE);

     }

   g_assert_not_reached ();

@@ -978,6 +1044,16 @@ _cogl_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)

   _COGL_GET_CONTEXT (ctxt, NO_RETVAL);

+  if (tex_pixmap->stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    {

+      cogl_object_unref (tex_pixmap->left);

+

+      /* Chain up */

+      _cogl_texture_free (COGL_TEXTURE (tex_pixmap));

+

+      return;

+    }

+

   display = cogl_xlib_renderer_get_display (ctxt->display->renderer);

   set_damage_object_internal (ctxt, tex_pixmap, 0, 0);

diff --git a/cogl/winsys/cogl-texture-pixmap-x11.h b/cogl/winsys/cogl-texture-pixmap-x11.h

index 5d78af3..a3652a4 100644

--- a/cogl/winsys/cogl-texture-pixmap-x11.h

+++ b/cogl/winsys/cogl-texture-pixmap-x11.h

@@ -103,6 +103,62 @@ cogl_texture_pixmap_x11_new (CoglContext *context,

                              CoglError **error);

 /**

+ * cogl_texture_pixmap_x11_new_left:

+ * @context: A #CoglContext

+ * @pixmap: A X11 pixmap ID

+ * @automatic_updates: Whether to automatically copy the contents of

+ * the pixmap to the texture.

+ * @error: A #CoglError for exceptions

+ *

+ * Creates one of a pair of textures to contain the contents of @pixmap,

+ * which has stereo content. (Different images for the right and left eyes.)

+ * The left image is drawn using this texture; the right image is drawn

+ * using a texture created by calling

+ * cogl_texture_pixmap_x11_new_right() and passing in this texture as an

+ * argument.

+ *

+ * In general, you should not use this function unless you have

+ * queried the %GLX_STEREO_TREE_EXT attribute of the corresponding

+ * window using glXQueryDrawable() and determined that the window is

+ * stereo. Note that this attribute can change over time and

+ * notification is also provided through events defined in the

+ * EXT_stereo_tree GLX extension. As long as the system has support for

+ * stereo content, drawing using the left and right pixmaps will not

+ * produce an error even if the window doesn't have stereo

+ * content any more, but drawing with the right pixmap will produce

+ * undefined output, so you need to listen for these events and

+ * re-render to avoid race conditions. (Recreating a non-stereo

+ * pixmap is not necessary, but may save resources.)

+ *

+ * Return value: a new #CoglTexturePixmapX11 instance

+ *

+ * Since: 1.20

+ * Stability: Unstable

+ */

+CoglTexturePixmapX11 *

+cogl_texture_pixmap_x11_new_left (CoglContext *context,

+                                  uint32_t pixmap,

+                                  CoglBool automatic_updates,

+                                  CoglError **error);

+

+/**

+ * cogl_texture_pixmap_x11_new_right:

+ * @left_texture: A #CoglTexturePixmapX11 instance created with

+ *                cogl_texture_pixmap_x11_new_left().

+ *

+ * Creates a texture object that corresponds to the right-eye image

+ * of a pixmap with stereo content. @left_texture must have been

+ * created using cogl_texture_pixmap_x11_new_left().

+ *

+ * Return value: a new #CoglTexturePixmapX11 instance

+ *

+ * Since: 1.20

+ * Stability: Unstable

+ */

+CoglTexturePixmapX11 *

+cogl_texture_pixmap_x11_new_right (CoglTexturePixmapX11 *left_texture);

+

+/**

  * cogl_texture_pixmap_x11_update_area:

  * @texture: A #CoglTexturePixmapX11 instance

  * @x: x coordinate of the area to update

diff --git a/cogl/winsys/cogl-winsys-egl-x11.c b/cogl/winsys/cogl-winsys-egl-x11.c

index 3e91b99..6752029 100644

--- a/cogl/winsys/cogl-winsys-egl-x11.c

+++ b/cogl/winsys/cogl-winsys-egl-x11.c

@@ -760,6 +760,7 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)

 static CoglBool

 _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

+                                        CoglBool right,

                                         CoglBool needs_mipmap)

 {

   if (needs_mipmap)

@@ -774,7 +775,8 @@ _cogl_winsys_texture_pixmap_x11_damage_notify (CoglTexturePixmapX11 *tex_pixmap)

 }

 static CoglTexture *

-_cogl_winsys_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)

+_cogl_winsys_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap,

+                                             CoglBool right)

 {

   CoglTexturePixmapEGL *egl_tex_pixmap = tex_pixmap->winsys;

diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c

index bff5178..334691c 100644

--- a/cogl/winsys/cogl-winsys-glx.c

+++ b/cogl/winsys/cogl-winsys-glx.c

@@ -89,16 +89,21 @@ typedef struct _CoglOnscreenGLX

   CoglBool pending_resize_notify;

 } CoglOnscreenGLX;

+typedef struct _CoglPixmapTextureEyeGLX

+{

+  CoglTexture *glx_tex;

+  CoglBool bind_tex_image_queued;

+  CoglBool pixmap_bound;

+} CoglPixmapTextureEyeGLX;

+

 typedef struct _CoglTexturePixmapGLX

 {

   GLXPixmap glx_pixmap;

   CoglBool has_mipmap_space;

   CoglBool can_mipmap;

-  CoglTexture *glx_tex;

-

-  CoglBool bind_tex_image_queued;

-  CoglBool pixmap_bound;

+  CoglPixmapTextureEyeGLX left;

+  CoglPixmapTextureEyeGLX right;

 } CoglTexturePixmapGLX;

 /* Define a set of arrays containing the functions required from GL

@@ -1965,6 +1970,7 @@ _cogl_winsys_xlib_get_visual_info (void)

 static CoglBool

 get_fbconfig_for_depth (CoglContext *context,

                         unsigned int depth,

+                        CoglBool stereo,

                         GLXFBConfig *fbconfig_ret,

                         CoglBool *can_mipmap_ret)

 {

@@ -1982,11 +1988,12 @@ get_fbconfig_for_depth (CoglContext *context,

   glx_renderer = context->display->renderer->winsys;

   glx_display = context->display->winsys;

-  /* Check if we've already got a cached config for this depth */

+  /* Check if we've already got a cached config for this depth and stereo */

   for (i = 0; i < COGL_GLX_N_CACHED_CONFIGS; i++)

     if (glx_display->glx_cached_configs[i].depth == -1)

       spare_cache_slot = i;

-    else if (glx_display->glx_cached_configs[i].depth == depth)

+    else if (glx_display->glx_cached_configs[i].depth == depth &&

+             glx_display->glx_cached_configs[i].stereo == stereo)

       {

         *fbconfig_ret = glx_display->glx_cached_configs[i].fb_config;

         *can_mipmap_ret = glx_display->glx_cached_configs[i].can_mipmap;

@@ -2030,6 +2037,13 @@ get_fbconfig_for_depth (CoglContext *context,

       if (value != depth && (value - alpha) != depth)

         continue;

+      glx_renderer->glXGetFBConfigAttrib (dpy,

+                                          fbconfigs[i],

+                                          GLX_STEREO,

+                                          &value);

+      if (!!value != !!stereo)

+        continue;

+

       if (glx_renderer->glx_major == 1 && glx_renderer->glx_minor >= 4)

         {

           glx_renderer->glXGetFBConfigAttrib (dpy,

@@ -2187,7 +2201,9 @@ try_create_glx_pixmap (CoglContext *context,

   glx_renderer = renderer->winsys;

   dpy = xlib_renderer->xdpy;

-  if (!get_fbconfig_for_depth (context, depth, &fb_config,

+  if (!get_fbconfig_for_depth (context, depth,

+                               tex_pixmap->stereo_mode != COGL_TEXTURE_PIXMAP_MONO,

+                               &fb_config,

                                &glx_tex_pixmap->can_mipmap))

     {

       COGL_NOTE (TEXTURE_PIXMAP, "No suitable FBConfig found for depth %i",

@@ -2276,10 +2292,13 @@ _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)

   glx_tex_pixmap->can_mipmap = FALSE;

   glx_tex_pixmap->has_mipmap_space = FALSE;

-  glx_tex_pixmap->glx_tex = NULL;

+  glx_tex_pixmap->left.glx_tex = NULL;

+  glx_tex_pixmap->right.glx_tex = NULL;

-  glx_tex_pixmap->bind_tex_image_queued = TRUE;

-  glx_tex_pixmap->pixmap_bound = FALSE;

+  glx_tex_pixmap->left.bind_tex_image_queued = TRUE;

+  glx_tex_pixmap->right.bind_tex_image_queued = TRUE;

+  glx_tex_pixmap->left.pixmap_bound = FALSE;

+  glx_tex_pixmap->right.pixmap_bound = FALSE;

   tex_pixmap->winsys = glx_tex_pixmap;

@@ -2306,10 +2325,14 @@ free_glx_pixmap (CoglContext *context,

   xlib_renderer = _cogl_xlib_renderer_get_data (renderer);

   glx_renderer = renderer->winsys;

-  if (glx_tex_pixmap->pixmap_bound)

+  if (glx_tex_pixmap->left.pixmap_bound)

     glx_renderer->glXReleaseTexImage (xlib_renderer->xdpy,

                                       glx_tex_pixmap->glx_pixmap,

                                       GLX_FRONT_LEFT_EXT);

+  if (glx_tex_pixmap->right.pixmap_bound)

+    glx_renderer->glXReleaseTexImage (xlib_renderer->xdpy,

+                                      glx_tex_pixmap->glx_pixmap,

+                                      GLX_FRONT_RIGHT_EXT);

   /* FIXME - we need to trap errors and synchronize here because

    * of ordering issues between the XPixmap destruction and the

@@ -2334,7 +2357,8 @@ free_glx_pixmap (CoglContext *context,

   _cogl_xlib_renderer_untrap_errors (renderer, &trap_state);

   glx_tex_pixmap->glx_pixmap = None;

-  glx_tex_pixmap->pixmap_bound = FALSE;

+  glx_tex_pixmap->left.pixmap_bound = FALSE;

+  glx_tex_pixmap->right.pixmap_bound = FALSE;

 }

 static void

@@ -2349,8 +2373,11 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)

   free_glx_pixmap (COGL_TEXTURE (tex_pixmap)->context, glx_tex_pixmap);

-  if (glx_tex_pixmap->glx_tex)

-    cogl_object_unref (glx_tex_pixmap->glx_tex);

+  if (glx_tex_pixmap->left.glx_tex)

+    cogl_object_unref (glx_tex_pixmap->left.glx_tex);

+

+  if (glx_tex_pixmap->right.glx_tex)

+    cogl_object_unref (glx_tex_pixmap->right.glx_tex);

   tex_pixmap->winsys = NULL;

   g_free (glx_tex_pixmap);

@@ -2358,13 +2385,27 @@ _cogl_winsys_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)

 static CoglBool

 _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

+                                        CoglTexturePixmapStereoMode stereo_mode,

                                         CoglBool needs_mipmap)

 {

   CoglTexture *tex = COGL_TEXTURE (tex_pixmap);

   CoglContext *ctx = COGL_TEXTURE (tex_pixmap)->context;

   CoglTexturePixmapGLX *glx_tex_pixmap = tex_pixmap->winsys;

+  CoglPixmapTextureEyeGLX *texture_info;

+  int buffer;

   CoglGLXRenderer *glx_renderer;

+  if (stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    {

+      texture_info = &glx_tex_pixmap->right;

+      buffer = GLX_FRONT_RIGHT_EXT;

+    }

+  else

+    {

+      texture_info = &glx_tex_pixmap->left;

+      buffer = GLX_FRONT_LEFT_EXT;

+    }

+

   /* If we don't have a GLX pixmap then fallback */

   if (glx_tex_pixmap->glx_pixmap == None)

     return FALSE;

@@ -2372,7 +2413,7 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

   glx_renderer = ctx->display->renderer->winsys;

   /* Lazily create a texture to hold the pixmap */

-  if (glx_tex_pixmap->glx_tex == NULL)

+  if (texture_info->glx_tex == NULL)

     {

       CoglPixelFormat texture_format;

       CoglError *error = NULL;

@@ -2383,14 +2424,14 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

       if (should_use_rectangle (ctx))

         {

-          glx_tex_pixmap->glx_tex = COGL_TEXTURE (

+          texture_info->glx_tex = COGL_TEXTURE (

             cogl_texture_rectangle_new_with_size (ctx,

                                                   tex->width,

                                                   tex->height,

                                                   texture_format,

                                                   &error));

-          if (glx_tex_pixmap->glx_tex)

+          if (texture_info->glx_tex)

             COGL_NOTE (TEXTURE_PIXMAP, "Created a texture rectangle for %p",

                        tex_pixmap);

           else

@@ -2405,13 +2446,13 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

         }

       else

         {

-          glx_tex_pixmap->glx_tex = COGL_TEXTURE (

+          texture_info->glx_tex = COGL_TEXTURE (

             cogl_texture_2d_new_with_size (ctx,

                                            tex->width,

                                            tex->height,

                                            texture_format));

-          if (cogl_texture_allocate (glx_tex_pixmap->glx_tex, &error))

+          if (cogl_texture_allocate (texture_info->glx_tex, &error))

             COGL_NOTE (TEXTURE_PIXMAP, "Created a texture 2d for %p",

                        tex_pixmap);

           else

@@ -2449,36 +2490,37 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

                          "updates for %p because creating the GLXPixmap "

                          "with mipmap support failed", tex_pixmap);

-              if (glx_tex_pixmap->glx_tex)

-                cogl_object_unref (glx_tex_pixmap->glx_tex);

+              if (texture_info->glx_tex)

+                cogl_object_unref (texture_info->glx_tex);

               return FALSE;

             }

-          glx_tex_pixmap->bind_tex_image_queued = TRUE;

+          glx_tex_pixmap->left.bind_tex_image_queued = TRUE;

+          glx_tex_pixmap->right.bind_tex_image_queued = TRUE;

         }

     }

-  if (glx_tex_pixmap->bind_tex_image_queued)

+  if (texture_info->bind_tex_image_queued)

     {

       GLuint gl_handle, gl_target;

       CoglXlibRenderer *xlib_renderer =

         _cogl_xlib_renderer_get_data (ctx->display->renderer);

-      cogl_texture_get_gl_texture (glx_tex_pixmap->glx_tex,

+      cogl_texture_get_gl_texture (texture_info->glx_tex,

                                    &gl_handle, &gl_target);

       COGL_NOTE (TEXTURE_PIXMAP, "Rebinding GLXPixmap for %p", tex_pixmap);

       _cogl_bind_gl_texture_transient (gl_target, gl_handle, FALSE);

-      if (glx_tex_pixmap->pixmap_bound)

+      if (texture_info->pixmap_bound)

         glx_renderer->glXReleaseTexImage (xlib_renderer->xdpy,

                                           glx_tex_pixmap->glx_pixmap,

-                                          GLX_FRONT_LEFT_EXT);

+                                          buffer);

       glx_renderer->glXBindTexImage (xlib_renderer->xdpy,

                                      glx_tex_pixmap->glx_pixmap,

-                                     GLX_FRONT_LEFT_EXT,

+                                     buffer,

                                      NULL);

       /* According to the recommended usage in the spec for

@@ -2491,10 +2533,10 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,

        * on Mesa and NVidia drivers and it is also what Compiz does so

        * it is probably ok */

-      glx_tex_pixmap->bind_tex_image_queued = FALSE;

-      glx_tex_pixmap->pixmap_bound = TRUE;

+      texture_info->bind_tex_image_queued = FALSE;

+      texture_info->pixmap_bound = TRUE;

-      _cogl_texture_2d_externally_modified (glx_tex_pixmap->glx_tex);

+      _cogl_texture_2d_externally_modified (texture_info->glx_tex);

     }

   return TRUE;

@@ -2505,15 +2547,20 @@ _cogl_winsys_texture_pixmap_x11_damage_notify (CoglTexturePixmapX11 *tex_pixmap)

 {

   CoglTexturePixmapGLX *glx_tex_pixmap = tex_pixmap->winsys;

-  glx_tex_pixmap->bind_tex_image_queued = TRUE;

+  glx_tex_pixmap->left.bind_tex_image_queued = TRUE;

+  glx_tex_pixmap->right.bind_tex_image_queued = TRUE;

 }

 static CoglTexture *

-_cogl_winsys_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap)

+_cogl_winsys_texture_pixmap_x11_get_texture (CoglTexturePixmapX11 *tex_pixmap,

+                                             CoglTexturePixmapStereoMode stereo_mode)

 {

   CoglTexturePixmapGLX *glx_tex_pixmap = tex_pixmap->winsys;

-  return glx_tex_pixmap->glx_tex;

+  if (stereo_mode == COGL_TEXTURE_PIXMAP_RIGHT)

+    return glx_tex_pixmap->right.glx_tex;

+  else

+    return glx_tex_pixmap->left.glx_tex;

 }

 static void

diff --git a/cogl/winsys/cogl-winsys-private.h b/cogl/winsys/cogl-winsys-private.h

index 7cd2b24..31a1af9 100644

--- a/cogl/winsys/cogl-winsys-private.h

+++ b/cogl/winsys/cogl-winsys-private.h

@@ -172,13 +172,15 @@ typedef struct _CoglWinsysVtable

   CoglBool

   (*texture_pixmap_x11_update) (CoglTexturePixmapX11 *tex_pixmap,

+                                CoglTexturePixmapStereoMode stereo_mode,

                                 CoglBool needs_mipmap);

   void

   (*texture_pixmap_x11_damage_notify) (CoglTexturePixmapX11 *tex_pixmap);

   CoglTexture *

-  (*texture_pixmap_x11_get_texture) (CoglTexturePixmapX11 *tex_pixmap);

+  (*texture_pixmap_x11_get_texture) (CoglTexturePixmapX11 *tex_pixmap,

+                                     CoglTexturePixmapStereoMode stereo_mode);

 #endif

   void

-- 

1.9.3