From 768818c8d071f066a2ab68f83381829838b5bf29 Mon Sep 17 00:00:00 2001

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

Date: Thu, 8 May 2014 18:44:15 -0400

Subject: [PATCH 1/2] Add support for quad-buffer stereo

Track the stereo status of windows using the new EXT_stereo_tree

GLX extension.

When stereo is enabled or disabled, a restart is triggered via

meta_restart() after a timeout, setting a _META_ENABLE_STEREO

property on the root window to indicate whether we should

turn on a stereo stage for clutter. The property avoids a loop,

since we need to enable stereo *before* initializing Clutter and GL,

but we need GL to figure out whether we have stereo windows.

Stereo windows are drawn to the stage using new functionality

in Cogl to setup a stereo context, select which buffer to draw

to, and draw either the left or right buffer of a stereo

texture_from_pixmap.

---

 clutter/clutter/clutter-paint-nodes.c        | 103 +++++++++++

 clutter/clutter/clutter-paint-nodes.h        |  13 ++

 src/compositor/compositor.c                  |   8 +

 src/compositor/meta-compositor-x11.c         | 127 +++++++++++++

 src/compositor/meta-compositor-x11.h         |   6 +

 src/compositor/meta-shaped-texture-private.h |   5 +-

 src/compositor/meta-shaped-texture.c         | 176 +++++++++++++++----

 src/compositor/meta-surface-actor-wayland.c  |   2 +-

 src/compositor/meta-surface-actor-x11.c      |  55 +++++-

 src/compositor/meta-surface-actor-x11.h      |   5 +

 src/compositor/meta-window-actor-private.h   |   5 +

 src/compositor/meta-window-actor.c           |  22 +++

 src/core/main.c                              |   4 +

 src/core/stereo.c                            | 154 ++++++++++++++++

 src/core/stereo.h                            |  28 +++

 src/meson.build                              |   2 +

 src/wayland/meta-wayland-actor-surface.c     |   4 +-

 17 files changed, 667 insertions(+), 52 deletions(-)

 create mode 100644 src/core/stereo.c

 create mode 100644 src/core/stereo.h

diff --git a/clutter/clutter/clutter-paint-nodes.c b/clutter/clutter/clutter-paint-nodes.c

index f1f7fce318..29a673e9c7 100644

--- a/clutter/clutter/clutter-paint-nodes.c

+++ b/clutter/clutter/clutter-paint-nodes.c

@@ -1970,3 +1970,106 @@ clutter_blur_node_new (unsigned int width,

 out:

   return (ClutterPaintNode *) blur_node;

 }

+

+/*

+ * ClutterStereoNode

+ */

+

+struct _ClutterStereoNode

+{

+  ClutterPaintNode parent_instance;

+

+  CoglStereoMode stereo_mode;

+};

+

+struct _ClutterStereoNodeClass

+{

+  ClutterPaintNodeClass parent_class;

+};

+

+G_DEFINE_TYPE (ClutterStereoNode, clutter_stereo_node, CLUTTER_TYPE_PAINT_NODE)

+

+static gboolean

+clutter_stereo_node_pre_draw (ClutterPaintNode    *node,

+                              ClutterPaintContext *paint_context)

+{

+  ClutterStereoNode *stereo_node = CLUTTER_STEREO_NODE (node);

+  CoglFramebuffer *fb =

+   clutter_paint_context_get_framebuffer (paint_context);

+

+  g_warn_if_fail (cogl_framebuffer_get_is_stereo (fb));

+

+  cogl_framebuffer_set_stereo_mode (fb, stereo_node->stereo_mode);

+

+  return TRUE;

+}

+

+static void

+clutter_stereo_node_post_draw (ClutterPaintNode    *node,

+                               ClutterPaintContext *paint_context)

+{

+  CoglFramebuffer *fb =

+   clutter_paint_context_get_framebuffer (paint_context);

+

+  cogl_framebuffer_set_stereo_mode (fb, COGL_STEREO_BOTH);

+}

+

+static const char *

+stereo_mode_to_string (CoglStereoMode stereo_mode)

+{

+  switch (stereo_mode)

+    {

+    case COGL_STEREO_BOTH:

+      return "both";

+    case COGL_STEREO_LEFT:

+      return "left";

+    case COGL_STEREO_RIGHT:

+      return "right";

+    }

+

+  g_assert_not_reached ();

+}

+

+static JsonNode *

+clutter_stereo_node_serialize (ClutterPaintNode *node)

+{

+  ClutterStereoNode *stereo_node = CLUTTER_STEREO_NODE (node);

+  g_autoptr (JsonBuilder) builder = NULL;

+  const char *stereo_mode_str;

+

+  builder = json_builder_new ();

+  json_builder_begin_object (builder);

+  json_builder_set_member_name (builder, "stereo-mode");

+  stereo_mode_str = stereo_mode_to_string (stereo_node->stereo_mode);

+  json_builder_add_string_value (builder, stereo_mode_str);

+  json_builder_end_object (builder);

+

+  return json_builder_get_root (builder);

+}

+

+static void

+clutter_stereo_node_class_init (ClutterStereoNodeClass *klass)

+{

+  ClutterPaintNodeClass *node_class;

+

+  node_class = CLUTTER_PAINT_NODE_CLASS (klass);

+  node_class->pre_draw = clutter_stereo_node_pre_draw;

+  node_class->post_draw = clutter_stereo_node_post_draw;

+  node_class->serialize = clutter_stereo_node_serialize;

+}

+

+static void

+clutter_stereo_node_init (ClutterStereoNode *stereo_node)

+{

+}

+

+ClutterPaintNode *

+clutter_stereo_node_new (CoglStereoMode stereo_mode)

+{

+  ClutterStereoNode *stereo_node;

+

+  stereo_node = _clutter_paint_node_create (CLUTTER_TYPE_STEREO_NODE);

+  stereo_node->stereo_mode = stereo_mode;

+

+  return CLUTTER_PAINT_NODE (stereo_node);

+}

diff --git a/clutter/clutter/clutter-paint-nodes.h b/clutter/clutter/clutter-paint-nodes.h

index 7f0d12857a..77d1ab05b6 100644

--- a/clutter/clutter/clutter-paint-nodes.h

+++ b/clutter/clutter/clutter-paint-nodes.h

@@ -284,6 +284,19 @@ ClutterPaintNode * clutter_blur_node_new (unsigned int width,

                                           unsigned int height,

                                           float        sigma);

+#define CLUTTER_TYPE_STEREO_NODE                (clutter_stereo_node_get_type ())

+#define CLUTTER_STEREO_NODE(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STEREO_NODE, ClutterStereoNode))

+#define CLUTTER_IS_STEREO_NODE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STEREO_NODE))

+

+typedef struct _ClutterStereoNode               ClutterStereoNode;

+typedef struct _ClutterStereoNodeClass          ClutterStereoNodeClass;

+

+CLUTTER_EXPORT

+GType clutter_stereo_node_get_type (void) G_GNUC_CONST;

+

+CLUTTER_EXPORT

+ClutterPaintNode * clutter_stereo_node_new (CoglStereoMode stereo_mode);

+

 G_END_DECLS

 #endif /* __CLUTTER_PAINT_NODES_H__ */

diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c

index 1770550d4c..a4bd1252ae 100644

--- a/src/compositor/compositor.c

+++ b/src/compositor/compositor.c

@@ -66,6 +66,7 @@

 #include "compositor/meta-window-actor-private.h"

 #include "compositor/meta-window-group-private.h"

 #include "core/frame.h"

+#include "core/stereo.h"

 #include "core/util-private.h"

 #include "core/window-private.h"

 #include "meta/compositor-mutter.h"

@@ -910,6 +911,7 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,

     meta_compositor_get_instance_private (compositor);

   MetaWindowActor *top_window_actor;

   GList *old_stack;

+  int stereo_window_count = 0;

   /* This is painful because hidden windows that we are in the process

    * of animating out of existence. They'll be at the bottom of the

@@ -986,12 +988,18 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,

        */

       priv->windows = g_list_prepend (priv->windows, actor);

+      if (meta_window_actor_is_stereo (actor))

+        stereo_window_count++;

+

       stack = g_list_remove (stack, window);

       old_stack = g_list_remove (old_stack, actor);

     }

   sync_actor_stacking (compositor);

+  if (!meta_is_wayland_compositor ())

+    meta_stereo_set_have_stereo_windows (stereo_window_count > 0);

+

   top_window_actor = get_top_visible_window_actor (compositor);

   if (priv->top_window_actor == top_window_actor)

diff --git a/src/compositor/meta-compositor-x11.c b/src/compositor/meta-compositor-x11.c

index 1d0ba4c8d8..afbe3f57e2 100644

--- a/src/compositor/meta-compositor-x11.c

+++ b/src/compositor/meta-compositor-x11.c

@@ -31,6 +31,8 @@

 #include "compositor/meta-sync-ring.h"

 #include "compositor/meta-window-actor-x11.h"

 #include "core/display-private.h"

+#include "core/stack-tracker.h"

+#include "core/stereo.h"

 #include "x11/meta-x11-display-private.h"

 struct _MetaCompositorX11

@@ -50,8 +52,24 @@ struct _MetaCompositorX11

   gboolean xserver_uses_monotonic_clock;

   int64_t xserver_time_query_time_us;

   int64_t xserver_time_offset_us;

+

+  int glx_opcode;

+  gboolean stereo_tree_ext;

+  gboolean have_stereo_windows;

 };

+typedef struct

+{

+  int type;

+  unsigned long serial;

+  Bool send_event;

+  Display *display;

+  int extension;

+  int evtype;

+  Drawable window;

+  Bool stereo_tree;

+} StereoNotifyEvent;

+

 G_DEFINE_TYPE (MetaCompositorX11, meta_compositor_x11, META_TYPE_COMPOSITOR)

 static void

@@ -95,6 +113,27 @@ meta_compositor_x11_process_xevent (MetaCompositorX11 *compositor_x11,

       if (window)

         process_damage (compositor_x11, (XDamageNotifyEvent *) xevent, window);

     }

+  else if (xevent->type == GenericEvent &&

+           xevent->xcookie.extension == compositor_x11->glx_opcode)

+    {

+      if (xevent->xcookie.evtype == GLX_STEREO_NOTIFY_EXT)

+        {

+          StereoNotifyEvent *stereo_event =

+            (StereoNotifyEvent *) (xevent->xcookie.data);

+

+          window = meta_x11_display_lookup_x_window (x11_display,

+                                                     stereo_event->window);

+          if (window)

+            {

+              MetaWindowActor *window_actor = meta_window_actor_from_window (window);

+              MetaDisplay *display = meta_window_get_display (window);

+

+              meta_window_actor_stereo_notify (window_actor,

+                                               stereo_event->stereo_tree);

+              meta_stack_tracker_queue_sync_stack (display->stack_tracker);

+            }

+        }

+    }

   if (compositor_x11->have_x11_sync_object)

     meta_sync_ring_handle_event (xevent);

@@ -107,6 +146,85 @@ meta_compositor_x11_process_xevent (MetaCompositorX11 *compositor_x11,

     meta_x11_handle_event (xevent);

 }

+#define GLX_STEREO_TREE_EXT        0x20F5

+#define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001

+#define GLX_STEREO_NOTIFY_EXT      0x00000000

+

+static gboolean

+display_has_stereo_tree_ext (MetaX11Display *x11_display)

+{

+  Display     *xdisplay = x11_display->xdisplay;

+  const char  *extensions_string;

+

+  static const char * (*query_extensions_string) (Display *display,

+                                                  int      screen);

+

+  if (query_extensions_string == NULL)

+    query_extensions_string =

+      (const char * (*) (Display *, int))

+      cogl_get_proc_address ("glXQueryExtensionsString");

+

+  extensions_string = query_extensions_string (xdisplay,

+                                               meta_x11_display_get_screen_number (x11_display));

+

+  return extensions_string && strstr (extensions_string, "EXT_stereo_tree") != 0;

+}

+

+#include <GL/gl.h>

+

+gboolean

+meta_compositor_x11_window_is_stereo (MetaCompositorX11 *compositor_x11,

+                                      Window             xwindow)

+{

+  MetaCompositor *compositor = META_COMPOSITOR (compositor_x11);

+  MetaDisplay *display = meta_compositor_get_display (compositor);

+  Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);

+

+  static int (*query_drawable) (Display      *dpy,

+                                Drawable      draw,

+                                int           attribute,

+                                unsigned int *value);

+

+  if (compositor_x11->stereo_tree_ext)

+    {

+      unsigned int stereo_tree = 0;

+

+      if (query_drawable == NULL)

+        query_drawable =

+          (int (*) (Display *, Drawable, int, unsigned int *))

+          cogl_get_proc_address ("glXQueryDrawable");

+

+      query_drawable (xdisplay, xwindow, GLX_STEREO_TREE_EXT, &stereo_tree);

+

+      return stereo_tree != 0;

+    }

+  else

+    return FALSE;

+}

+

+void

+meta_compositor_x11_select_stereo_notify (MetaCompositorX11 *compositor_x11,

+                                          Window             xwindow)

+{

+  MetaCompositor *compositor = META_COMPOSITOR (compositor_x11);

+  MetaDisplay *display = meta_compositor_get_display (compositor);

+  Display *xdisplay = meta_x11_display_get_xdisplay (display->x11_display);

+

+  static void (*select_event) (Display      *dpy,

+                               Drawable      draw,

+                               unsigned long event_mask);

+

+  if (compositor_x11->stereo_tree_ext)

+    {

+      if (select_event == NULL)

+        select_event =

+          (void (*) (Display *, Drawable, unsigned long))

+          cogl_get_proc_address ("glXSelectEvent");

+

+      select_event (xdisplay, xwindow, GLX_STEREO_NOTIFY_MASK_EXT);

+    }

+}

+

 static void

 determine_server_clock_source (MetaCompositorX11 *compositor_x11)

 {

@@ -142,6 +260,7 @@ meta_compositor_x11_manage (MetaCompositor  *compositor,

   MetaX11Display *x11_display = display->x11_display;

   Display *xdisplay = meta_x11_display_get_xdisplay (x11_display);

   int composite_version;

+  int glx_major_opcode, glx_first_event, glx_first_error;

   MetaBackend *backend = meta_get_backend ();

   Window xwindow;

@@ -166,10 +285,18 @@ meta_compositor_x11_manage (MetaCompositor  *compositor,

       return FALSE;

     }

+  if (XQueryExtension (xdisplay,

+                       "GLX",

+                       &glx_major_opcode, &glx_first_event, &glx_first_error))

+    compositor_x11->glx_opcode = glx_major_opcode;

+

   determine_server_clock_source (compositor_x11);

   meta_x11_display_set_cm_selection (display->x11_display);

+  compositor_x11->stereo_tree_ext =

+    display_has_stereo_tree_ext (display->x11_display);

+

   compositor_x11->output = display->x11_display->composite_overlay_window;

   xwindow = meta_backend_x11_get_xwindow (META_BACKEND_X11 (backend));

diff --git a/src/compositor/meta-compositor-x11.h b/src/compositor/meta-compositor-x11.h

index 42554feb39..61f3cd5950 100644

--- a/src/compositor/meta-compositor-x11.h

+++ b/src/compositor/meta-compositor-x11.h

@@ -36,4 +36,10 @@ void meta_compositor_x11_process_xevent (MetaCompositorX11 *compositor_x11,

 Window meta_compositor_x11_get_output_xwindow (MetaCompositorX11 *compositor_x11);

+gboolean meta_compositor_x11_window_is_stereo (MetaCompositorX11 *compositor_x11,

+                                               Window             xwindow);

+

+void meta_compositor_x11_select_stereo_notify (MetaCompositorX11 *compositor_x11,

+                                               Window             xwindow);

+

 #endif /* META_COMPOSITOR_X11_H */

diff --git a/src/compositor/meta-shaped-texture-private.h b/src/compositor/meta-shaped-texture-private.h

index 2fe1b8ea48..fadad07d69 100644

--- a/src/compositor/meta-shaped-texture-private.h

+++ b/src/compositor/meta-shaped-texture-private.h

@@ -31,8 +31,9 @@

 #include "meta/meta-shaped-texture.h"

 MetaShapedTexture *meta_shaped_texture_new (void);

-void meta_shaped_texture_set_texture (MetaShapedTexture *stex,

-                                      CoglTexture       *texture);

+void meta_shaped_texture_set_textures (MetaShapedTexture *stex,

+                                       CoglTexture       *texture,

+                                       CoglTexture       *texture_right);

 void meta_shaped_texture_set_is_y_inverted (MetaShapedTexture *stex,

                                             gboolean           is_y_inverted);

 void meta_shaped_texture_set_snippet (MetaShapedTexture *stex,

diff --git a/src/compositor/meta-shaped-texture.c b/src/compositor/meta-shaped-texture.c

index 6a8af828f0..43170a195d 100644

--- a/src/compositor/meta-shaped-texture.c

+++ b/src/compositor/meta-shaped-texture.c

@@ -83,8 +83,10 @@ struct _MetaShapedTexture

   GObject parent;

   MetaTextureTower *paint_tower;

+  MetaTextureTower *paint_tower_right;

   CoglTexture *texture;

+  CoglTexture *texture_right;

   CoglTexture *mask_texture;

   CoglSnippet *snippet;

@@ -151,6 +153,7 @@ static void

 meta_shaped_texture_init (MetaShapedTexture *stex)

 {

   stex->paint_tower = meta_texture_tower_new ();

+  stex->paint_tower_right = NULL;

   stex->buffer_scale = 1;

   stex->texture = NULL;

@@ -251,11 +254,11 @@ meta_shaped_texture_dispose (GObject *object)

   g_clear_handle_id (&stex->remipmap_timeout_id, g_source_remove);

-  if (stex->paint_tower)

-    meta_texture_tower_free (stex->paint_tower);

-  stex->paint_tower = NULL;

+  g_clear_pointer (&stex->paint_tower, meta_texture_tower_free);

+  g_clear_pointer (&stex->paint_tower_right, meta_texture_tower_free);

   g_clear_pointer (&stex->texture, cogl_object_unref);

+  g_clear_pointer (&stex->texture_right, cogl_object_unref);

   meta_shaped_texture_set_mask_texture (stex, NULL);

   meta_shaped_texture_reset_pipelines (stex);

@@ -521,14 +524,19 @@ paint_clipped_rectangle_node (MetaShapedTexture     *stex,

 }

 static void

-set_cogl_texture (MetaShapedTexture *stex,

-                  CoglTexture       *cogl_tex)

+set_cogl_textures (MetaShapedTexture *stex,

+                   CoglTexture       *cogl_tex,

+                   CoglTexture       *cogl_tex_right)

 {

   int width, height;

   cogl_clear_object (&stex->texture);

+  cogl_clear_object (&stex->texture_right);

-  if (cogl_tex != NULL)

+  stex->texture = cogl_tex;

+  stex->texture_right = cogl_tex_right;

+

+  if (cogl_tex)

     {

       stex->texture = cogl_object_ref (cogl_tex);

       width = cogl_texture_get_width (COGL_TEXTURE (cogl_tex));

@@ -540,6 +548,9 @@ set_cogl_texture (MetaShapedTexture *stex,

       height = 0;

     }

+  if (cogl_tex_right)

+    cogl_object_ref (cogl_tex_right);

+

   if (stex->tex_width != width ||

       stex->tex_height != height)

     {

@@ -553,8 +564,23 @@ set_cogl_texture (MetaShapedTexture *stex,

    * previous buffer. We only queue a redraw in response to surface

    * damage. */

+  if (cogl_tex_right)

+    {

+      if (!stex->paint_tower_right)

+        stex->paint_tower_right = meta_texture_tower_new ();

+    }

+  else

+    {

+      g_clear_pointer (&stex->paint_tower_right, meta_texture_tower_free);

+    }

+

   if (stex->create_mipmaps)

-    meta_texture_tower_set_base_texture (stex->paint_tower, cogl_tex);

+    {

+      meta_texture_tower_set_base_texture (stex->paint_tower, cogl_tex);

+

+      if (stex->paint_tower_right)

+        meta_texture_tower_set_base_texture (stex->paint_tower_right, cogl_tex_right);

+    }

 }

 static gboolean

@@ -582,6 +608,19 @@ flip_ints (int *x,

   *y = tmp;

 }

+static CoglFramebuffer *

+get_target_framebuffer (ClutterPaintNode    *root_node,

+                        ClutterPaintContext *paint_context)

+{

+  CoglFramebuffer *framebuffer;

+

+  framebuffer = clutter_paint_node_get_framebuffer (root_node);

+  if (!framebuffer)

+    framebuffer = clutter_paint_context_get_framebuffer (paint_context);

+

+  return framebuffer;

+}

+

 static void

 do_paint_content (MetaShapedTexture   *stex,

                   ClutterPaintNode    *root_node,

@@ -622,9 +661,7 @@ do_paint_content (MetaShapedTexture   *stex,

    * improves performance, especially with software rendering.

    */

-  framebuffer = clutter_paint_node_get_framebuffer (root_node);

-  if (!framebuffer)

-    framebuffer = clutter_paint_context_get_framebuffer (paint_context);

+  framebuffer = get_target_framebuffer (root_node, paint_context);

   if (stex->has_viewport_src_rect)

     {

@@ -826,13 +863,27 @@ do_paint_content (MetaShapedTexture   *stex,

 static CoglTexture *

 select_texture_for_paint (MetaShapedTexture   *stex,

-                          ClutterPaintContext *paint_context)

+                          ClutterPaintContext *paint_context,

+                          CoglStereoMode       stereo_mode)

 {

   CoglTexture *texture = NULL;

   int64_t now;

+  gboolean use_right_texture = FALSE;

-  if (!stex->texture)

-    return NULL;

+  switch (stereo_mode)

+    {

+    case COGL_STEREO_LEFT:

+    case COGL_STEREO_BOTH:

+      if (!stex->texture)

+        return NULL;

+      use_right_texture = FALSE;

+      break;

+    case COGL_STEREO_RIGHT:

+      if (!stex->texture_right)

+        return NULL;

+      use_right_texture = TRUE;

+      break;

+    }

   now = g_get_monotonic_time ();

@@ -843,14 +894,24 @@ select_texture_for_paint (MetaShapedTexture   *stex,

       if (age >= MIN_MIPMAP_AGE_USEC ||

           stex->fast_updates < MIN_FAST_UPDATES_BEFORE_UNMIPMAP)

         {

-          texture = meta_texture_tower_get_paint_texture (stex->paint_tower,

+          MetaTextureTower *paint_tower;

+

+          if (use_right_texture)

+            paint_tower = stex->paint_tower_right;

+          else

+            paint_tower = stex->paint_tower;

+

+          texture = meta_texture_tower_get_paint_texture (paint_tower,

                                                           paint_context);

         }

     }

   if (!texture)

     {

-      texture = stex->texture;

+      if (use_right_texture)

+        texture = stex->texture_right;

+      else

+        texture = stex->texture;

       if (stex->create_mipmaps)

         {

@@ -876,35 +937,57 @@ meta_shaped_texture_paint_content (ClutterContent      *content,

 {

   MetaShapedTexture *stex = META_SHAPED_TEXTURE (content);

   ClutterActorBox alloc;

-  CoglTexture *paint_tex = NULL;

   uint8_t opacity;

+  CoglFramebuffer *framebuffer;

+  gboolean is_stereo;

   if (stex->clip_region && cairo_region_is_empty (stex->clip_region))

     return;

-  /* The GL EXT_texture_from_pixmap extension does allow for it to be

-   * used together with SGIS_generate_mipmap, however this is very

-   * rarely supported. Also, even when it is supported there

-   * are distinct performance implications from:

-   *

-   *  - Updating mipmaps that we don't need

-   *  - Having to reallocate pixmaps on the server into larger buffers

-   *

-   * So, we just unconditionally use our mipmap emulation code. If we

-   * wanted to use SGIS_generate_mipmap, we'd have to  query COGL to

-   * see if it was supported (no API currently), and then if and only

-   * if that was the case, set the clutter texture quality to HIGH.

-   * Setting the texture quality to high without SGIS_generate_mipmap

-   * support for TFP textures will result in fallbacks to XGetImage.

-   */

-  paint_tex = select_texture_for_paint (stex, paint_context);

-  if (!paint_tex)

+  if (!stex->texture)

     return;

   opacity = clutter_actor_get_paint_opacity (actor);

   clutter_actor_get_content_box (actor, &alloc);

-  do_paint_content (stex, root_node, paint_context, paint_tex, &alloc, opacity);

+  framebuffer = get_target_framebuffer (root_node, paint_context);

+  is_stereo = (stex->texture_right &&

+               cogl_framebuffer_get_is_stereo (framebuffer));

+

+  if (is_stereo)

+    {

+      CoglTexture *texture_left;

+      CoglTexture *texture_right;

+      g_autoptr (ClutterPaintNode) left_node = NULL;

+      g_autoptr (ClutterPaintNode) right_node = NULL;

+

+      texture_left = select_texture_for_paint (stex, paint_context,

+                                               COGL_STEREO_LEFT);

+      texture_right = select_texture_for_paint (stex, paint_context,

+                                                COGL_STEREO_RIGHT);

+

+      left_node = clutter_stereo_node_new (COGL_STEREO_LEFT);

+      clutter_paint_node_set_static_name (left_node, "MetaShapedTexture (left)");

+      right_node = clutter_stereo_node_new (COGL_STEREO_RIGHT);

+      clutter_paint_node_set_static_name (right_node, "MetaShapedTexture (right)");

+

+      clutter_paint_node_add_child (root_node, left_node);

+      clutter_paint_node_add_child (root_node, right_node);

+

+      do_paint_content (stex, left_node, paint_context,

+                        texture_left, &alloc, opacity);

+      do_paint_content (stex, right_node, paint_context,

+                        texture_right, &alloc, opacity);

+    }

+  else

+    {

+      CoglTexture *texture;

+

+      texture = select_texture_for_paint (stex, paint_context,

+                                          COGL_STEREO_BOTH);

+      do_paint_content (stex, root_node, paint_context,

+                        texture, &alloc, opacity);

+    }

 }

 static gboolean

@@ -946,6 +1029,12 @@ meta_shaped_texture_set_create_mipmaps (MetaShapedTexture *stex,

       stex->create_mipmaps = create_mipmaps;

       base_texture = create_mipmaps ? stex->texture : NULL;

       meta_texture_tower_set_base_texture (stex->paint_tower, base_texture);

+

+      if (stex->paint_tower_right)

+        {

+          base_texture = create_mipmaps ? stex->texture_right : NULL;

+          meta_texture_tower_set_base_texture (stex->paint_tower_right, base_texture);

+        }

     }

 }

@@ -1079,6 +1168,14 @@ meta_shaped_texture_update_area (MetaShapedTexture     *stex,

                                   y,

                                   width,

                                   height);

+  if (stex->paint_tower_right)

+    {

+      meta_texture_tower_update_area (stex->paint_tower_right,

+                                      x,

+                                      y,

+                                      width,

+                                      height);

+    }

   stex->prev_invalidation = stex->last_invalidation;

   stex->last_invalidation = g_get_monotonic_time ();

@@ -1098,20 +1195,21 @@ meta_shaped_texture_update_area (MetaShapedTexture     *stex,

 }

 /**