From ac946bf95ce3e4dc900f72dcb4189dd49bdb3155 Mon Sep 17 00:00:00 2001

From: Daniel van Vugt <daniel.van.vugt@canonical.com>

Date: Thu, 18 Jul 2019 16:56:41 +0800

Subject: [PATCH 1/4] clutter/point: Add ClutterPoint quarilateral testing API

Add a function to check whether a point is inside a quadrilateral

by checking the cross product of vectors with the quadrilateral

points, and the point being checked.

If the passed quadrilateral is zero-sized, no point is ever reported

to be inside it.

This will be used by the next commit when comparing the transformed

actor vertices.

[feaneron: add a commit message and remove unecessary code]

https://gitlab.gnome.org/GNOME/mutter/merge_requests/189

---

 clutter/clutter/clutter-base-types.c | 62 ++++++++++++++++++++++++++++

 clutter/clutter/clutter-types.h      |  3 ++

 2 files changed, 65 insertions(+)

diff --git a/clutter/clutter/clutter-base-types.c b/clutter/clutter/clutter-base-types.c

index aeb25c90ef..c84f9aa64b 100644

--- a/clutter/clutter/clutter-base-types.c

+++ b/clutter/clutter/clutter-base-types.c

@@ -570,6 +570,68 @@ G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterPoint, clutter_point,

                                clutter_point_free,

                                CLUTTER_REGISTER_INTERVAL_PROGRESS (clutter_point_progress))

+static int

+clutter_point_compare_line (const ClutterPoint *p,

+                            const ClutterPoint *a,

+                            const ClutterPoint *b)

+{

+  float x1 = b->x - a->x;

+  float y1 = b->y - a->y;

+  float x2 = p->x - a->x;

+  float y2 = p->y - a->y;

+  float cross_z = x1 * y2 - y1 * x2;

+

+  if (cross_z > 0.f)

+    return 1;

+  else if (cross_z < 0.f)

+    return -1;

+  else

+    return 0;

+}

+

+/**

+ * clutter_point_inside_quadrilateral:

+ * @point: a #ClutterPoint to test

+ * @vertices: array of vertices of the quadrilateral, in clockwise order,

+ *            from top-left to bottom-left

+ *

+ * Determines whether a point is inside the convex quadrilateral provided,

+ * and not on any of its edges or vertices.

+ *

+ * Returns: %TRUE if @point is inside the quadrilateral

+ */

+gboolean

+clutter_point_inside_quadrilateral (const ClutterPoint *point,

+                                    const ClutterPoint *vertices)

+{

+  unsigned int i;

+  int first_side;

+

+  first_side = 0;

+

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

+    {

+      int side;

+

+      side = clutter_point_compare_line (point,

+                                         &vertices[i],

+                                         &vertices[(i + 1) % 4]);

+

+      if (side)

+        {

+          if (first_side == 0)

+            first_side = side;

+          else if (side != first_side)

+            return FALSE;

+        }

+    }

+

+  if (first_side == 0)

+    return FALSE;

+

+  return TRUE;

+}

+

 /*

diff --git a/clutter/clutter/clutter-types.h b/clutter/clutter/clutter-types.h

index 0f0fb1c2ac..0508028273 100644

--- a/clutter/clutter/clutter-types.h

+++ b/clutter/clutter/clutter-types.h

@@ -200,6 +200,9 @@ float                   clutter_point_distance  (const ClutterPoint *a,

                                                  const ClutterPoint *b,

                                                  float              *x_distance,

                                                  float              *y_distance);

+CLUTTER_EXPORT

+gboolean clutter_point_inside_quadrilateral     (const ClutterPoint *point,

+                                                 const ClutterPoint *vertices);

 /**

  * ClutterSize:

-- 

2.29.2

From 8abac81711cfef8317bb675349d6b5b0a79eb05d Mon Sep 17 00:00:00 2001

From: Daniel van Vugt <daniel.van.vugt@canonical.com>

Date: Thu, 2 Aug 2018 19:03:30 +0800

Subject: [PATCH 2/4] clutter: Introduce geometric picking

Currently, Clutter does picking by drawing with Cogl and reading

the pixel that's beneath the given point. Since Cogl has a journal

that records drawing operations, and has optimizations to read a

single pixel from a list of rectangle, it would be expected that

we would hit this fast path and not flush the journal while picking.

However, that's not the case: dithering, clipping with scissors, etc,

can all flush the journal, issuing commands to the GPU and making

picking slow. On NVidia-based systems, this glReadPixels() call is

extremely costly.

Introduce geometric picking, and avoid using the Cogl journal entirely.

Do this by introducing a stack of actors in ClutterStage. This stack

is cached, but for now, don't use the cache as much as possible.

The picking routines are still tied to painting.

When projecting the actor vertexes, do it manually and take the modelview

matrix of the framebuffer into account as well.

CPU usage on an Intel i7-7700, tested with two different GPUs/drivers:

  |         |     Intel | Nvidia |

  | ------: | --------: | -----: |

  | Moving the mouse:            |

  | Before  |       10% |    10% |

  | After   |        6% |     6% |

  | Moving a window:             |

  | Before  |       23% |    81% |

  | After   |       19% |    40% |

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/154,

        https://gitlab.gnome.org/GNOME/mutter/issues/691

Helps significantly with: https://gitlab.gnome.org/GNOME/mutter/issues/283,

                          https://gitlab.gnome.org/GNOME/mutter/issues/590,

                          https://gitlab.gnome.org/GNOME/mutter/issues/700

v2: Fix code style issues

    Simplify quadrilateral checks

    Remove the 0.5f hack

    Differentiate axis-aligned rectangles

https://gitlab.gnome.org/GNOME/mutter/merge_requests/189

---

 clutter/clutter/clutter-actor-private.h      |   2 -

 clutter/clutter/clutter-actor.c              | 232 ++++++----

 clutter/clutter/clutter-actor.h              |   4 +

 clutter/clutter/clutter-debug.h              |   1 -

 clutter/clutter/clutter-main.c               | 120 -----

 clutter/clutter/clutter-private.h            |   5 -

 clutter/clutter/clutter-stage-private.h      |  16 +-

 clutter/clutter/clutter-stage-window.c       |  18 -

 clutter/clutter/clutter-stage-window.h       |   8 -

 clutter/clutter/clutter-stage.c              | 459 +++++++++++--------

 clutter/clutter/cogl/clutter-stage-cogl.c    |  52 ---

 clutter/clutter/deprecated/clutter-texture.c |  93 +---

 clutter/tests/conform/actor-pick.c           |  99 +---

 clutter/tests/conform/meson.build            |   1 -

 clutter/tests/conform/texture.c              |  84 ----

 src/compositor/meta-surface-actor.c          |  27 +-

 16 files changed, 439 insertions(+), 782 deletions(-)

 delete mode 100644 clutter/tests/conform/texture.c

diff --git a/clutter/clutter/clutter-actor-private.h b/clutter/clutter/clutter-actor-private.h

index c44f6342fd..9bf1a30493 100644

--- a/clutter/clutter/clutter-actor-private.h

+++ b/clutter/clutter/clutter-actor-private.h

@@ -297,8 +297,6 @@ const gchar *                   _clutter_actor_get_debug_name

 void                            _clutter_actor_push_clone_paint                         (void);

 void                            _clutter_actor_pop_clone_paint                          (void);

-guint32                         _clutter_actor_get_pick_id                              (ClutterActor *self);

-

 void                            _clutter_actor_shader_pre_paint                         (ClutterActor *actor,

                                                                                          gboolean      repeat);

 void                            _clutter_actor_shader_post_paint                        (ClutterActor *actor);

diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c

index 43093fe79d..01ffa51caa 100644

--- a/clutter/clutter/clutter-actor.c

+++ b/clutter/clutter/clutter-actor.c

@@ -730,8 +730,6 @@ struct _ClutterActorPrivate

   gchar *name; /* a non-unique name, used for debugging */

-  gint32 pick_id; /* per-stage unique id, used for picking */

-

   /* a back-pointer to the Pango context that we can use

    * to create pre-configured PangoLayout

    */

@@ -1281,6 +1279,105 @@ clutter_actor_verify_map_state (ClutterActor *self)

 #endif /* CLUTTER_ENABLE_DEBUG */

+static gboolean

+_clutter_actor_transform_local_box_to_stage (ClutterActor          *self,

+                                             ClutterStage          *stage,

+                                             const ClutterActorBox *box,

+                                             ClutterPoint           vertices[4])

+{

+  CoglFramebuffer *fb = cogl_get_draw_framebuffer ();

+  CoglMatrix stage_transform, inv_stage_transform;

+  CoglMatrix modelview, transform_to_stage;

+  int v;

+

+  clutter_actor_get_transform (CLUTTER_ACTOR (stage), &stage_transform);

+  if (!cogl_matrix_get_inverse (&stage_transform, &inv_stage_transform))

+    return FALSE;

+  cogl_framebuffer_get_modelview_matrix (fb, &modelview);

+  cogl_matrix_multiply (&transform_to_stage, &inv_stage_transform, &modelview);

+

+  vertices[0].x = box->x1;

+  vertices[0].y = box->y1;

+

+  vertices[1].x = box->x2;

+  vertices[1].y = box->y1;

+

+  vertices[2].x = box->x2;

+  vertices[2].y = box->y2;

+

+  vertices[3].x = box->x1;

+  vertices[3].y = box->y2;

+

+  for (v = 0; v < 4; v++)

+    {

+      float z = 0.f;

+      float w = 1.f;

+

+      cogl_matrix_transform_point (&transform_to_stage,

+                                   &vertices[v].x,

+                                   &vertices[v].y,

+                                   &z,

+                                   &w);

+    }

+

+  return TRUE;

+}

+

+/**

+ * clutter_actor_pick_box:

+ * @self: The #ClutterActor being "pick" painted.

+ * @box: A rectangle in the actor's own local coordinates.

+ *

+ * Logs (does a virtual paint of) a rectangle for picking. Note that @box is

+ * in the actor's own local coordinates, so is usually {0,0,width,height}

+ * to include the whole actor. That is unless the actor has a shaped input

+ * region in which case you may wish to log the (multiple) smaller rectangles

+ * that make up the input region.

+ */

+void

+clutter_actor_pick_box (ClutterActor          *self,

+                        const ClutterActorBox *box)

+{

+  ClutterStage *stage;

+  ClutterPoint vertices[4];

+

+  g_return_if_fail (CLUTTER_IS_ACTOR (self));

+  g_return_if_fail (box != NULL);

+

+  if (box->x1 >= box->x2 || box->y1 >= box->y2)

+    return;

+

+  stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self));

+

+  if (_clutter_actor_transform_local_box_to_stage (self, stage, box, vertices))

+    clutter_stage_log_pick (stage, vertices, self);

+}

+

+static gboolean

+_clutter_actor_push_pick_clip (ClutterActor          *self,

+                               const ClutterActorBox *clip)

+{

+  ClutterStage *stage;

+  ClutterPoint vertices[4];

+

+  stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self));

+

+  if (!_clutter_actor_transform_local_box_to_stage (self, stage, clip, vertices))

+    return FALSE;

+

+  clutter_stage_push_pick_clip (stage, vertices);

+  return TRUE;

+}

+

+static void

+_clutter_actor_pop_pick_clip (ClutterActor *self)

+{

+  ClutterActor *stage;

+

+  stage = _clutter_actor_get_stage_internal (self);

+  clutter_stage_pop_pick_clip (CLUTTER_STAGE (stage));

+}

+

 static void

 clutter_actor_set_mapped (ClutterActor *self,

                           gboolean      mapped)

@@ -1509,8 +1606,7 @@ clutter_actor_update_map_state (ClutterActor  *self,

 static void

 clutter_actor_real_map (ClutterActor *self)

 {

-  ClutterActorPrivate *priv = self->priv;

-  ClutterActor *stage, *iter;

+  ClutterActor *iter;

   g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));

@@ -1521,13 +1617,6 @@ clutter_actor_real_map (ClutterActor *self)

   self->priv->needs_paint_volume_update = TRUE;

-  stage = _clutter_actor_get_stage_internal (self);

-  priv->pick_id = _clutter_stage_acquire_pick_id (CLUTTER_STAGE (stage), self);

-

-  CLUTTER_NOTE (ACTOR, "Pick id '%d' for actor '%s'",

-                priv->pick_id,

-                _clutter_actor_get_debug_name (self));

-

   clutter_actor_ensure_resource_scale (self);

   /* notify on parent mapped before potentially mapping

@@ -1632,11 +1721,6 @@ clutter_actor_real_unmap (ClutterActor *self)

       stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self));

-      if (stage != NULL)

-        _clutter_stage_release_pick_id (stage, priv->pick_id);

-

-      priv->pick_id = -1;

-

       if (stage != NULL &&

           clutter_stage_get_key_focus (stage) == self)

         {

@@ -2255,46 +2339,16 @@ static void

 clutter_actor_real_pick (ClutterActor       *self,

 			 const ClutterColor *color)

 {

-  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();

-

-  /* the default implementation is just to paint a rectangle

-   * with the same size of the actor using the passed color

-   */

   if (clutter_actor_should_pick_paint (self))

     {

-      static CoglPipeline *default_pick_pipeline = NULL;

-      ClutterActorBox box = { 0, };

-      CoglPipeline *pick_pipeline;

-      float width, height;

-

-      if (G_UNLIKELY (default_pick_pipeline == NULL))

-        {

-          CoglContext *ctx =

-            clutter_backend_get_cogl_context (clutter_get_default_backend ());

-

-          default_pick_pipeline = cogl_pipeline_new (ctx);

-        }

-

-      g_assert (default_pick_pipeline != NULL);

-      pick_pipeline = cogl_pipeline_copy (default_pick_pipeline);

+      ClutterActorBox box = {

+        .x1 = 0,

+        .y1 = 0,

+        .x2 = clutter_actor_get_width (self),

+        .y2 = clutter_actor_get_height (self),

+      };

-      clutter_actor_get_allocation_box (self, &box);

-

-      width = box.x2 - box.x1;

-      height = box.y2 - box.y1;

-

-      cogl_pipeline_set_color4ub (pick_pipeline,

-                                  color->red,

-                                  color->green,

-                                  color->blue,

-                                  color->alpha);

-

-      cogl_framebuffer_draw_rectangle (framebuffer,

-                                       pick_pipeline,

-                                       0, 0,

-                                       width, height);

-

-      cogl_object_unref (pick_pipeline);

+      clutter_actor_pick_box (self, &box);

     }

   /* XXX - this thoroughly sucks, but we need to maintain compatibility

@@ -3585,15 +3639,6 @@ _clutter_actor_update_last_paint_volume (ClutterActor *self)

   priv->last_paint_volume_valid = TRUE;

 }

-guint32

-_clutter_actor_get_pick_id (ClutterActor *self)

-{

-  if (self->priv->pick_id < 0)

-    return 0;

-

-  return self->priv->pick_id;

-}

-

 /* This is the same as clutter_actor_add_effect except that it doesn't

    queue a redraw and it doesn't notify on the effect property */

 static void

@@ -3826,6 +3871,7 @@ clutter_actor_paint (ClutterActor *self)

   ClutterActorPrivate *priv;

   ClutterPickMode pick_mode;

   gboolean culling_inhibited;

+  ClutterActorBox clip;

   gboolean clip_set = FALSE;

   ClutterStage *stage;

@@ -3919,24 +3965,38 @@ clutter_actor_paint (ClutterActor *self)

   if (priv->has_clip)

     {

-      CoglFramebuffer *fb = _clutter_stage_get_active_framebuffer (stage);

-      cogl_framebuffer_push_rectangle_clip (fb,

-                                            priv->clip.origin.x,

-                                            priv->clip.origin.y,

-                                            priv->clip.origin.x + priv->clip.size.width,

-                                            priv->clip.origin.y + priv->clip.size.height);

+      clip.x1 = priv->clip.origin.x;

+      clip.y1 = priv->clip.origin.y;

+      clip.x2 = priv->clip.origin.x + priv->clip.size.width;

+      clip.y2 = priv->clip.origin.y + priv->clip.size.height;

       clip_set = TRUE;

     }

   else if (priv->clip_to_allocation)

     {

-      CoglFramebuffer *fb = _clutter_stage_get_active_framebuffer (stage);

-      gfloat width, height;

+      clip.x1 = 0.f;

+      clip.y1 = 0.f;

+      clip.x2 = priv->allocation.x2 - priv->allocation.x1;

+      clip.y2 = priv->allocation.y2 - priv->allocation.y1;

+      clip_set = TRUE;

+    }

-      width  = priv->allocation.x2 - priv->allocation.x1;

-      height = priv->allocation.y2 - priv->allocation.y1;

+  if (clip_set)

+    {

+      if (pick_mode == CLUTTER_PICK_NONE)

+        {

+          CoglFramebuffer *fb = _clutter_stage_get_active_framebuffer (stage);

-      cogl_framebuffer_push_rectangle_clip (fb, 0, 0, width, height);

-      clip_set = TRUE;

+          cogl_framebuffer_push_rectangle_clip (fb,

+                                                clip.x1,

+                                                clip.y1,

+                                                clip.x2,

+                                                clip.y2);

+        }

+      else

+        {

+          if (!_clutter_actor_push_pick_clip (self, &clip))

+            clip_set = FALSE;

+        }

     }

   if (pick_mode == CLUTTER_PICK_NONE)

@@ -4020,9 +4080,16 @@ clutter_actor_paint (ClutterActor *self)

 done:

   if (clip_set)

     {

-      CoglFramebuffer *fb = _clutter_stage_get_active_framebuffer (stage);

+      if (pick_mode == CLUTTER_PICK_NONE)

+        {

+          CoglFramebuffer *fb = _clutter_stage_get_active_framebuffer (stage);

-      cogl_framebuffer_pop_clip (fb);

+          cogl_framebuffer_pop_clip (fb);

+        }

+      else

+        {

+          _clutter_actor_pop_pick_clip (self);

+        }

     }

   cogl_pop_matrix ();

@@ -4093,11 +4160,12 @@ clutter_actor_continue_paint (ClutterActor *self)

         {

           ClutterColor col = { 0, };

-          _clutter_id_to_color (_clutter_actor_get_pick_id (self), &col);

-

-          /* Actor will then paint silhouette of itself in supplied

-           * color.  See clutter_stage_get_actor_at_pos() for where

-           * picking is enabled.

+          /* The actor will log a silhouette of itself to the stage pick log.

+           * Note that the picking color is no longer used as the "log" instead

+           * keeps a weak pointer to the actor itself. But we keep the color

+           * parameter for now so as to maintain ABI compatibility. The color

+           * parameter can be removed when someone feels like breaking the ABI

+           * along with gnome-shell.

            *

            * XXX:2.0 - Call the pick() virtual directly

            */

@@ -8603,8 +8671,6 @@ clutter_actor_init (ClutterActor *self)

   self->priv = priv = clutter_actor_get_instance_private (self);

-  priv->pick_id = -1;

-

   priv->opacity = 0xff;

   priv->show_on_set_parent = TRUE;

   priv->resource_scale = -1.0f;

diff --git a/clutter/clutter/clutter-actor.h b/clutter/clutter/clutter-actor.h

index 3e7a59ac0c..16b438ba64 100644

--- a/clutter/clutter/clutter-actor.h

+++ b/clutter/clutter/clutter-actor.h

@@ -910,6 +910,10 @@ void                            clutter_actor_bind_model_with_properties

                                                                                  const char                 *first_model_property,

                                                                                  ...);

+CLUTTER_EXPORT

+void clutter_actor_pick_box (ClutterActor          *self,

+                             const ClutterActorBox *box);

+

 G_END_DECLS

 #endif /* __CLUTTER_ACTOR_H__ */

diff --git a/clutter/clutter/clutter-debug.h b/clutter/clutter/clutter-debug.h

index 2462385f65..7d170d2d54 100644

--- a/clutter/clutter/clutter-debug.h

+++ b/clutter/clutter/clutter-debug.h

@@ -30,7 +30,6 @@ typedef enum

 typedef enum

 {

   CLUTTER_DEBUG_NOP_PICKING         = 1 << 0,

-  CLUTTER_DEBUG_DUMP_PICK_BUFFERS   = 1 << 1

 } ClutterPickDebugFlag;

 typedef enum

diff --git a/clutter/clutter/clutter-main.c b/clutter/clutter/clutter-main.c

index 645c8bceb6..11c221a65b 100644

--- a/clutter/clutter/clutter-main.c

+++ b/clutter/clutter/clutter-main.c

@@ -131,7 +131,6 @@ static const GDebugKey clutter_debug_keys[] = {

 static const GDebugKey clutter_pick_debug_keys[] = {

   { "nop-picking", CLUTTER_DEBUG_NOP_PICKING },

-  { "dump-pick-buffers", CLUTTER_DEBUG_DUMP_PICK_BUFFERS },

 };

 static const GDebugKey clutter_paint_debug_keys[] = {

@@ -533,125 +532,6 @@ clutter_get_motion_events_enabled (void)

   return _clutter_context_get_motion_events_enabled ();

 }

-void

-_clutter_id_to_color (guint         id_,

-                      ClutterColor *col)

-{

-  ClutterMainContext *ctx;

-  gint red, green, blue;

-

-  ctx = _clutter_context_get_default ();

-

-  if (ctx->fb_g_mask == 0)

-    {

-      /* Figure out framebuffer masks used for pick */

-      cogl_get_bitmasks (&ctx->fb_r_mask,

-			 &ctx->fb_g_mask,

-			 &ctx->fb_b_mask, NULL);

-

-      ctx->fb_r_mask_used = ctx->fb_r_mask;

-      ctx->fb_g_mask_used = ctx->fb_g_mask;

-      ctx->fb_b_mask_used = ctx->fb_b_mask;

-

-      /* XXX - describe what "fuzzy picking" is */

-      if (clutter_use_fuzzy_picking)

-	{

-	  ctx->fb_r_mask_used--;

-	  ctx->fb_g_mask_used--;

-	  ctx->fb_b_mask_used--;

-	}

-    }

-

-  /* compute the numbers we'll store in the components */

-  red   = (id_ >> (ctx->fb_g_mask_used+ctx->fb_b_mask_used))

-        & (0xff >> (8-ctx->fb_r_mask_used));

-  green = (id_ >> ctx->fb_b_mask_used)

-        & (0xff >> (8-ctx->fb_g_mask_used));

-  blue  = (id_)

-        & (0xff >> (8-ctx->fb_b_mask_used));

-

-  /* shift left bits a bit and add one, this circumvents

-   * at least some potential rounding errors in GL/GLES

-   * driver / hw implementation.

-   */

-  if (ctx->fb_r_mask_used != ctx->fb_r_mask)

-    red = red * 2;

-  if (ctx->fb_g_mask_used != ctx->fb_g_mask)

-    green = green * 2;

-  if (ctx->fb_b_mask_used != ctx->fb_b_mask)

-    blue  = blue  * 2;

-

-  /* shift up to be full 8bit values */

-  red   = (red   << (8 - ctx->fb_r_mask)) | (0x7f >> (ctx->fb_r_mask_used));

-  green = (green << (8 - ctx->fb_g_mask)) | (0x7f >> (ctx->fb_g_mask_used));

-  blue  = (blue  << (8 - ctx->fb_b_mask)) | (0x7f >> (ctx->fb_b_mask_used));

-

-  col->red   = red;

-  col->green = green;

-  col->blue  = blue;

-  col->alpha = 0xff;

-

-  /* XXX: We rotate the nibbles of the colors here so that there is a

-   * visible variation between colors of sequential actor identifiers;

-   * otherwise pick buffers dumped to an image will pretty much just look

-   * black.

-   */

-  if (G_UNLIKELY (clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS))

-    {

-      col->red   = (col->red << 4)   | (col->red >> 4);

-      col->green = (col->green << 4) | (col->green >> 4);

-      col->blue  = (col->blue << 4)  | (col->blue >> 4);

-    }

-}

-

-guint

-_clutter_pixel_to_id (guchar pixel[4])

-{

-  ClutterMainContext *ctx;

-  gint red, green, blue;

-  guint retval;

-

-  ctx = _clutter_context_get_default ();

-

-  /* reduce the pixel components to the number of bits actually used of the

-   * 8bits.

-   */

-  if (G_UNLIKELY (clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS))

-    {

-      guchar tmp;

-

-      /* XXX: In _clutter_id_to_color we rotated the nibbles of the colors so

-       * that there is a visible variation between colors of sequential actor

-       * identifiers (otherwise pick buffers dumped to an image will pretty

-       * much just look black.) Here we reverse that rotation.

-       */

-      tmp = ((pixel[0] << 4) | (pixel[0] >> 4));

-      red = tmp >> (8 - ctx->fb_r_mask);

-      tmp = ((pixel[1] << 4) | (pixel[1] >> 4));

-      green = tmp >> (8 - ctx->fb_g_mask);

-      tmp = ((pixel[2] << 4) | (pixel[2] >> 4));

-      blue = tmp >> (8 - ctx->fb_b_mask);

-    }

-  else

-    {

-      red   = pixel[0] >> (8 - ctx->fb_r_mask);

-      green = pixel[1] >> (8 - ctx->fb_g_mask);

-      blue  = pixel[2] >> (8 - ctx->fb_b_mask);

-    }

-

-  /* divide potentially by two if 'fuzzy' */

-  red   = red   >> (ctx->fb_r_mask - ctx->fb_r_mask_used);

-  green = green >> (ctx->fb_g_mask - ctx->fb_g_mask_used);

-  blue  = blue  >> (ctx->fb_b_mask - ctx->fb_b_mask_used);

-

-  /* combine the correct per component values into the final id */

-  retval = blue

-         + (green <<  ctx->fb_b_mask_used)

-         + (red << (ctx->fb_b_mask_used + ctx->fb_g_mask_used));

-

-  return retval;

-}

-

 static CoglPangoFontMap *

 clutter_context_get_pango_fontmap (void)

 {

diff --git a/clutter/clutter/clutter-private.h b/clutter/clutter/clutter-private.h

index 5a0fed85c9..f2f870b014 100644

--- a/clutter/clutter/clutter-private.h

+++ b/clutter/clutter/clutter-private.h

@@ -210,11 +210,6 @@ gboolean      _clutter_feature_init (GError **error);

 gboolean        _clutter_diagnostic_enabled     (void);

 void            _clutter_diagnostic_message     (const char *fmt, ...) G_GNUC_PRINTF (1, 2);

-/* Picking code */

-guint           _clutter_pixel_to_id            (guchar        pixel[4]);

-void            _clutter_id_to_color            (guint         id,

-                                                 ClutterColor *col);

-

 void            _clutter_set_sync_to_vblank     (gboolean      sync_to_vblank);

 /* use this function as the accumulator if you have a signal with

diff --git a/clutter/clutter/clutter-stage-private.h b/clutter/clutter/clutter-stage-private.h

index 42474687ad..51ae47af1d 100644

--- a/clutter/clutter/clutter-stage-private.h

+++ b/clutter/clutter/clutter-stage-private.h

@@ -75,6 +75,15 @@ gint64    _clutter_stage_get_update_time                  (ClutterStage *stage);

 void     _clutter_stage_clear_update_time                 (ClutterStage *stage);

 gboolean _clutter_stage_has_full_redraw_queued            (ClutterStage *stage);

+void clutter_stage_log_pick (ClutterStage       *stage,

+                             const ClutterPoint *vertices,

+                             ClutterActor       *actor);

+

+void clutter_stage_push_pick_clip (ClutterStage       *stage,