clutter/actor: Revert transform order

When doing affine transforms on 2D and 3D spaces, operations are
done relative to the origin. That means that, when applying
rotations and scales, we must:

 * translate (-anchor_x, -anchor_y, -anchor_z)
 * apply the operation
 * translate (anchor_x, anchor_y, anchor_z)

Since OpenGL has its matrices applied in the reverse order, the
usual way to do it is, then:

 * translate (anchor_x, anchor_y, anchor_z)
 * apply the operation
 * translate (-anchor_x, anchor_y, anchor_z)

However, graphene matrices do not follow the GL format, so matrix
operations are done as the first example. Now that we are using
graphene_matrix_t for every matrix operation, the transform order
is wrong.

Apply the transform operations in the opposite order.

.gitlab-ci/Dockerfile

@@ -5,13 +5,13 @@ RUN dnf -y update && dnf -y upgrade && \
     dnf builddep -y mutter && \
 
     # Until Fedora catches up with meson build-deps
-    dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
+    dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland graphene-devel && \
 
     # For running unit tests
     dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
 
     # Unpackaged versions
-    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
+    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
 
     dnf install -y intltool redhat-rpm-config make && \
     dnf clean all

clutter/clutter/cally/cally-actor.c

@@ -657,7 +657,7 @@ cally_actor_get_extents (AtkComponent *component,
   ClutterActor *actor      = NULL;
   gint          top_level_x, top_level_y;
   gfloat        f_width, f_height;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];
   ClutterActor  *stage = NULL;
 
   g_return_if_fail (CALLY_IS_ACTOR (component));

clutter/clutter/cally/cally-text.c

@@ -1438,7 +1438,7 @@ static void cally_text_get_character_extents (AtkText *text,
   PangoLayout *layout;
   PangoRectangle extents;
   const gchar *text_value;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];
 
   actor = CALLY_GET_CLUTTER_ACTOR (text);
   if (actor == NULL) /* State is defunct */
@@ -2294,7 +2294,7 @@ _cally_misc_get_index_at_point (ClutterText *clutter_text,
   gint index, x_window, y_window, x_toplevel, y_toplevel;
   gint x_temp, y_temp;
   gboolean ret;
-  ClutterVertex verts[4];
+  graphene_point3d_t verts[4];
   PangoLayout *layout;
   gint x_layout, y_layout;
 

clutter/clutter/clutter-actor-box.c

@@ -340,7 +340,7 @@ clutter_actor_box_contains (const ClutterActorBox *box,
 /**
  * clutter_actor_box_from_vertices:
  * @box: a #ClutterActorBox
- * @verts: (array fixed-size=4): array of four #ClutterVertex
+ * @verts: (array fixed-size=4): array of four #graphene_point3d_t
  *
  * Calculates the bounding box represented by the four vertices; for details
  * of the vertex array see clutter_actor_get_abs_allocation_vertices().
@@ -349,7 +349,7 @@ clutter_actor_box_contains (const ClutterActorBox *box,
  */
 void
 clutter_actor_box_from_vertices (ClutterActorBox     *box,
-                                 const ClutterVertex  verts[])
+                                 const graphene_point3d_t  verts[])
 {
   gfloat x_1, x_2, y_1, y_2;
 

clutter/clutter/clutter-actor-private.h

@@ -135,7 +135,7 @@ struct _AnchorCoord
     } fraction;
 
     /* Use when is_fractional == FALSE */
-    ClutterVertex units;
+    graphene_point3d_t units;
   } v;
 };
 
@@ -163,7 +163,7 @@ struct _SizeRequest
 struct _ClutterLayoutInfo
 {
   /* fixed position coordinates */
-  ClutterPoint fixed_pos;
+  graphene_point_t fixed_pos;
 
   ClutterMargin margin;
 
@@ -173,8 +173,8 @@ struct _ClutterLayoutInfo
   guint x_expand : 1;
   guint y_expand : 1;
 
-  ClutterSize minimum;
-  ClutterSize natural;
+  graphene_size_t minimum;
+  graphene_size_t natural;
 };
 
 const ClutterLayoutInfo *       _clutter_actor_get_layout_info_or_defaults      (ClutterActor *self);
@@ -203,13 +203,13 @@ struct _ClutterTransformInfo
   AnchorCoord anchor;
 
   /* translation */
-  ClutterVertex translation;
+  graphene_point3d_t translation;
 
   /* z_position */
   gfloat z_position;
 
   /* transformation center */
-  ClutterPoint pivot;
+  graphene_point_t pivot;
   gfloat pivot_z;
 
   CoglMatrix transform;

clutter/clutter/clutter-actor.c

@@ -36,15 +36,15 @@
  * or clutter_actor_set_rotation(). The order in which the transformations are
  * applied is decided by Clutter and it is the following:
  *
- *  1. translation by the origin of the #ClutterActor:allocation property
- *  2. translation by the actor's #ClutterActor:z-position property
- *  3. translation by the actor's #ClutterActor:pivot-point property
- *  4. scaling by the #ClutterActor:scale-x and #ClutterActor:scale-y factors
+ *  1. negative translation by the actor's #ClutterActor:pivot-point
+ *  2. negative translation by the #ClutterActor:anchor-x and #ClutterActor:anchor-y point.
+ *  3. rotation around the #ClutterActor:rotation-angle-z and #ClutterActor:rotation-center-z
+ *  4. rotation around the #ClutterActor:rotation-angle-y and #ClutterActor:rotation-center-y
  *  5. rotation around the #ClutterActor:rotation-angle-x and #ClutterActor:rotation-center-x
- *  6. rotation around the #ClutterActor:rotation-angle-y and #ClutterActor:rotation-center-y
- *  7. rotation around the #ClutterActor:rotation-angle-z and #ClutterActor:rotation-center-z
- *  8. negative translation by the #ClutterActor:anchor-x and #ClutterActor:anchor-y point.
- *  9. negative translation by the actor's #ClutterActor:pivot-point
+ *  6. scaling by the #ClutterActor:scale-x and #ClutterActor:scale-y factors
+ *  7. translation by the actor's #ClutterActor:pivot-point property
+ *  8. translation by the actor's #ClutterActor:z-position property
+ *  9. translation by the origin of the #ClutterActor:allocation property
  *
  * ## Modifying an actor's geometry ## {#clutter-actor-geometry}
  *
@@ -694,7 +694,7 @@ struct _ClutterActorPrivate
   ClutterAllocationFlags allocation_flags;
 
   /* clip, in actor coordinates */
-  ClutterRect clip;
+  graphene_rect_t clip;
 
   /* the cached transformation matrix; see apply_transform() */
   CoglMatrix transform;
@@ -896,7 +896,6 @@ enum
   PROP_DEPTH, /* XXX:2.0 remove */
   PROP_Z_POSITION,
 
-  PROP_CLIP, /* XXX:2.0 remove */
   PROP_CLIP_RECT,
   PROP_HAS_CLIP,
   PROP_CLIP_TO_ALLOCATION,
@@ -1070,8 +1069,6 @@ static ClutterGravity clutter_anchor_coord_get_gravity (const AnchorCoord *coord
 static void           clutter_anchor_coord_set_gravity (AnchorCoord       *coord,
                                                         ClutterGravity     gravity);
 
-static gboolean clutter_anchor_coord_is_zero (const AnchorCoord *coord);
-
 static void _clutter_actor_get_relative_transformation_matrix (ClutterActor *self,
                                                                ClutterActor *ancestor,
                                                                CoglMatrix *matrix);
@@ -1112,9 +1109,9 @@ static void clutter_actor_pop_in_cloned_branch (ClutterActor *self,
 #define TRANSFORM_ABOUT_ANCHOR_COORD(a,m,c,_transform)  G_STMT_START { \
   gfloat _tx, _ty, _tz;                                                \
   clutter_anchor_coord_get_units ((a), (c), &_tx, &_ty, &_tz);         \
-  cogl_matrix_translate ((m), _tx, _ty, _tz);                          \
+  cogl_matrix_translate ((m), -_tx, -_ty, -_tz);                       \
   { _transform; }                                                      \
-  cogl_matrix_translate ((m), -_tx, -_ty, -_tz);        } G_STMT_END
+  cogl_matrix_translate ((m), _tx, _ty, _tz);        } G_STMT_END
 
 static GQuark quark_actor_layout_info = 0;
 static GQuark quark_actor_transform_info = 0;
@@ -2826,8 +2823,8 @@ clutter_actor_real_queue_relayout (ClutterActor *self)
  * @self: A #ClutterActor
  * @ancestor: (allow-none): A #ClutterActor ancestor, or %NULL to use the
  *   default #ClutterStage
- * @point: A point as #ClutterVertex
- * @vertex: (out caller-allocates): The translated #ClutterVertex
+ * @point: A point as #graphene_point3d_t
+ * @vertex: (out caller-allocates): The translated #graphene_point3d_t
  *
  * Transforms @point in coordinates relative to the actor into
  * ancestor-relative coordinates using the relevant transform
@@ -2841,10 +2838,10 @@ clutter_actor_real_queue_relayout (ClutterActor *self)
  * Since: 0.6
  */
 void
-clutter_actor_apply_relative_transform_to_point (ClutterActor        *self,
-						 ClutterActor        *ancestor,
-						 const ClutterVertex *point,
-						 ClutterVertex       *vertex)
+clutter_actor_apply_relative_transform_to_point (ClutterActor             *self,
+                                                 ClutterActor             *ancestor,
+                                                 const graphene_point3d_t *point,
+                                                 graphene_point3d_t       *vertex)
 {
   gfloat w;
   CoglMatrix matrix;
@@ -2871,10 +2868,10 @@ clutter_actor_apply_relative_transform_to_point (ClutterActor        *self,
 }
 
 static gboolean
-_clutter_actor_fully_transform_vertices (ClutterActor *self,
-                                         const ClutterVertex *vertices_in,
-                                         ClutterVertex *vertices_out,
-                                         int n_vertices)
+_clutter_actor_fully_transform_vertices (ClutterActor             *self,
+                                         const graphene_point3d_t *vertices_in,
+                                         graphene_point3d_t       *vertices_out,
+                                         int                       n_vertices)
 {
   ClutterActor *stage;
   CoglMatrix modelview;
@@ -2916,8 +2913,8 @@ _clutter_actor_fully_transform_vertices (ClutterActor *self,
 /**
  * clutter_actor_apply_transform_to_point:
  * @self: A #ClutterActor
- * @point: A point as #ClutterVertex
- * @vertex: (out caller-allocates): The translated #ClutterVertex
+ * @point: A point as #graphene_point3d_t
+ * @vertex: (out caller-allocates): The translated #graphene_point3d_t
  *
  * Transforms @point in coordinates relative to the actor
  * into screen-relative coordinates with the current actor
@@ -2926,9 +2923,9 @@ _clutter_actor_fully_transform_vertices (ClutterActor *self,
  * Since: 0.4
  **/
 void
-clutter_actor_apply_transform_to_point (ClutterActor        *self,
-                                        const ClutterVertex *point,
-                                        ClutterVertex       *vertex)
+clutter_actor_apply_transform_to_point (ClutterActor             *self,
+                                        const graphene_point3d_t *point,
+                                        graphene_point3d_t       *vertex)
 {
   g_return_if_fail (point != NULL);
   g_return_if_fail (vertex != NULL);
@@ -2978,10 +2975,10 @@ _clutter_actor_get_relative_transformation_matrix (ClutterActor *self,
  * transformed vertices to @verts[]. */
 static gboolean
 _clutter_actor_transform_and_project_box (ClutterActor          *self,
-					  const ClutterActorBox *box,
-					  ClutterVertex          verts[])
+                                          const ClutterActorBox *box,
+                                          graphene_point3d_t    *verts)
 {
-  ClutterVertex box_vertices[4];
+  graphene_point3d_t box_vertices[4];
 
   box_vertices[0].x = box->x1;
   box_vertices[0].y = box->y1;
@@ -3005,8 +3002,8 @@ _clutter_actor_transform_and_project_box (ClutterActor          *self,
  * @self: A #ClutterActor
  * @ancestor: (allow-none): A #ClutterActor to calculate the vertices
  *   against, or %NULL to use the #ClutterStage
- * @verts: (out) (array fixed-size=4) (element-type Clutter.Vertex): return
- *   location for an array of 4 #ClutterVertex in which to store the result
+ * @verts: (out) (array fixed-size=4): return
+ *   location for an array of 4 #graphene_point3d_t in which to store the result
  *
  * Calculates the transformed coordinates of the four corners of the
  * actor in the plane of @ancestor. The returned vertices relate to
@@ -3025,13 +3022,13 @@ _clutter_actor_transform_and_project_box (ClutterActor          *self,
  * Since: 0.6
  */
 void
-clutter_actor_get_allocation_vertices (ClutterActor  *self,
-                                       ClutterActor  *ancestor,
-                                       ClutterVertex  verts[])
+clutter_actor_get_allocation_vertices (ClutterActor       *self,
+                                       ClutterActor       *ancestor,
+                                       graphene_point3d_t *verts)
 {
   ClutterActorPrivate *priv;
   ClutterActorBox box;
-  ClutterVertex vertices[4];
+  graphene_point3d_t vertices[4];
   CoglMatrix modelview;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
@@ -3083,9 +3080,9 @@ clutter_actor_get_allocation_vertices (ClutterActor  *self,
 
   cogl_matrix_transform_points (&modelview,
                                 3,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                 vertices,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                 vertices,
                                 4);
 }
@@ -3094,7 +3091,7 @@ clutter_actor_get_allocation_vertices (ClutterActor  *self,
  * clutter_actor_get_abs_allocation_vertices:
  * @self: A #ClutterActor
  * @verts: (out) (array fixed-size=4): Pointer to a location of an array
- *   of 4 #ClutterVertex where to store the result.
+ *   of 4 #graphene_point3d_t where to store the result.
  *
  * Calculates the transformed screen coordinates of the four corners of
  * the actor; the returned vertices relate to the #ClutterActorBox
@@ -3108,8 +3105,8 @@ clutter_actor_get_allocation_vertices (ClutterActor  *self,
  * Since: 0.4
  */
 void
-clutter_actor_get_abs_allocation_vertices (ClutterActor  *self,
-                                           ClutterVertex  verts[])
+clutter_actor_get_abs_allocation_vertices (ClutterActor       *self,
+                                           graphene_point3d_t *verts)
 {
   ClutterActorPrivate *priv;
   ClutterActorBox actor_space_allocation;
@@ -3151,6 +3148,7 @@ clutter_actor_real_apply_transform (ClutterActor  *self,
   CoglMatrix *transform = &priv->transform;
   const ClutterTransformInfo *info;
   float pivot_x = 0.f, pivot_y = 0.f;
+  float tx, ty, tz;
 
   /* we already have a cached transformation */
   if (priv->transform_valid)
@@ -3194,42 +3192,45 @@ clutter_actor_real_apply_transform (ClutterActor  *self,
        * space, and to the pivot point
        */
       cogl_matrix_translate (transform,
-                             priv->allocation.x1 + pivot_x,
-                             priv->allocation.y1 + pivot_y,
-                             info->pivot_z);
-      cogl_matrix_multiply (transform, transform, &info->transform);
+                             -pivot_x,
+                             -pivot_y,
+                             -info->pivot_z);
+      cogl_matrix_multiply (transform, &info->transform, transform);
+      cogl_matrix_translate (transform,
+                             priv->allocation.x1,
+                             priv->allocation.y1,
+                             0.0f);
       goto roll_back_pivot;
     }
 
-  /* basic translation: :allocation's origin and :z-position; instead
-   * of decomposing the pivot and translation info separate operations,
-   * we just compose everything into a single translation
-   */
-  cogl_matrix_translate (transform,
-                         priv->allocation.x1 + pivot_x + info->translation.x,
-                         priv->allocation.y1 + pivot_y + info->translation.y,
-                         info->z_position + info->pivot_z + info->translation.z);
+  /* XXX:2.0 remove anchor point translation */
+  clutter_anchor_coord_get_units (self, &info->anchor, &tx, &ty, &tz);
+  tx += pivot_x;
+  ty += pivot_y;
+  tz += info->pivot_z;
 
-  /* because the rotation involves translations, we must scale
-   * before applying the rotations (if we apply the scale after
-   * the rotations, the translations included in the rotation are
-   * not scaled and so the entire object will move on the screen
-   * as a result of rotating it).
-   *
-   * XXX:2.0 the comment has to be reworded once we remove the
-   * per-transformation centers; we also may want to apply rotation
-   * first and scaling after, to match the matrix decomposition
-   * code we use when interpolating transformations
-   */
-  if (info->scale_x != 1.0 || info->scale_y != 1.0 || info->scale_z != 1.0)
+  if (tx != 0.f || ty != 0.f || tz != 0.f)
+    cogl_matrix_translate (transform, -tx, -ty, -tz);
+
+  if (info->rx_angle)
     {
       /* XXX:2.0 remove anchor coord */
       TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
-                                    &info->scale_center,
-                                    cogl_matrix_scale (transform,
-                                                       info->scale_x,
-                                                       info->scale_y,
-                                                       info->scale_z));
+                                    &info->rx_center,
+                                    cogl_matrix_rotate (transform,
+                                                        info->rx_angle,
+                                                        1.0, 0, 0));
+    }
+
+
+  if (info->ry_angle)
+    {
+      /* XXX:2.0 remove anchor coord */
+      TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
+                                    &info->ry_center,
+                                    cogl_matrix_rotate (transform,
+                                                        info->ry_angle,
+                                                        0, 1.0, 0));
     }
 
   if (info->rz_angle)
@@ -3242,39 +3243,26 @@ clutter_actor_real_apply_transform (ClutterActor  *self,
                                                         0, 0, 1.0));
     }
 
-  if (info->ry_angle)
+  if (info->scale_x != 1.0 || info->scale_y != 1.0 || info->scale_z != 1.0)
     {
       /* XXX:2.0 remove anchor coord */
       TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
-                                    &info->ry_center,
-                                    cogl_matrix_rotate (transform,
-                                                        info->ry_angle,
-                                                        0, 1.0, 0));
+                                    &info->scale_center,
+                                    cogl_matrix_scale (transform,
+                                                       info->scale_x,
+                                                       info->scale_y,
+                                                       info->scale_z));
     }
 
-  if (info->rx_angle)
-    {
-      /* XXX:2.0 remove anchor coord */
-      TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
-                                    &info->rx_center,
-                                    cogl_matrix_rotate (transform,
-                                                        info->rx_angle,
-                                                        1.0, 0, 0));
-    }
-
-  /* XXX:2.0 remove anchor point translation */
-  if (!clutter_anchor_coord_is_zero (&info->anchor))
-    {
-      gfloat x, y, z;
-
-      clutter_anchor_coord_get_units (self, &info->anchor, &x, &y, &z);
-      cogl_matrix_translate (transform, -x, -y, -z);
-    }
+  cogl_matrix_translate (transform,
+                         priv->allocation.x1 + info->translation.x,
+                         priv->allocation.y1 + info->translation.y,
+                         info->z_position + info->translation.z);
 
 roll_back_pivot:
   /* roll back the pivot translation */
   if (pivot_x != 0.f || pivot_y != 0.f || info->pivot_z != 0.f)
-    cogl_matrix_translate (transform, -pivot_x, -pivot_y, -info->pivot_z);
+    cogl_matrix_translate (transform, pivot_x, pivot_y, info->pivot_z);
 
   /* we have a valid modelview */
   priv->transform_valid = TRUE;
@@ -3350,7 +3338,7 @@ _clutter_actor_draw_paint_volume_full (ClutterActor *self,
 {
   static CoglPipeline *outline = NULL;
   CoglPrimitive *prim;
-  ClutterVertex line_ends[12 * 2];
+  graphene_point3d_t line_ends[12 * 2];
   int n_vertices;
   CoglContext *ctx =
     clutter_backend_get_cogl_context (clutter_get_default_backend ());
@@ -4398,11 +4386,11 @@ static const ClutterTransformInfo default_transform_info = {
 
   { 0, },                       /* anchor XXX:2.0 - remove*/
 
-  CLUTTER_VERTEX_INIT_ZERO,     /* translation */
+  GRAPHENE_POINT3D_INIT_ZERO,     /* translation */
 
   0.f,                          /* z-position */
 
-  CLUTTER_POINT_INIT_ZERO,      /* pivot */
+  GRAPHENE_POINT_INIT_ZERO,     /* pivot */
   0.f,                          /* pivot-z */
 
   CLUTTER_MATRIX_INIT_IDENTITY,
@@ -4481,8 +4469,8 @@ _clutter_actor_get_transform_info (ClutterActor *self)
 }
 
 static inline void
-clutter_actor_set_pivot_point_internal (ClutterActor       *self,
-                                        const ClutterPoint *pivot)
+clutter_actor_set_pivot_point_internal (ClutterActor           *self,
+                                        const graphene_point_t *pivot)
 {
   ClutterTransformInfo *info;
 
@@ -4789,9 +4777,9 @@ clutter_actor_get_rotation_angle (ClutterActor      *self,
 static inline void
 clutter_actor_set_rotation_center_internal (ClutterActor        *self,
                                             ClutterRotateAxis    axis,
-                                            const ClutterVertex *center)
+                                            const graphene_point3d_t *center)
 {
-  ClutterVertex v = CLUTTER_VERTEX_INIT_ZERO; 
+  graphene_point3d_t v = GRAPHENE_POINT3D_INIT_ZERO;
   GObject *obj = G_OBJECT (self);
   ClutterTransformInfo *info;
 
@@ -5018,8 +5006,8 @@ clutter_actor_set_anchor_coord (ClutterActor      *self,
 }
 
 static void
-clutter_actor_set_clip_rect (ClutterActor      *self,
-                             const ClutterRect *clip)
+clutter_actor_set_clip_rect (ClutterActor          *self,
+                             const graphene_rect_t *clip)
 {
   ClutterActorPrivate *priv = self->priv;
   GObject *obj = G_OBJECT (self);
@@ -5034,7 +5022,6 @@ clutter_actor_set_clip_rect (ClutterActor      *self,
 
   clutter_actor_queue_redraw (self);
 
-  g_object_notify_by_pspec (obj, obj_props[PROP_CLIP]); /* XXX:2.0 - remove */
   g_object_notify_by_pspec (obj, obj_props[PROP_CLIP_RECT]);
   g_object_notify_by_pspec (obj, obj_props[PROP_HAS_CLIP]);
 }
@@ -5060,7 +5047,7 @@ clutter_actor_set_property (GObject      *object,
 
     case PROP_POSITION:
       {
-        const ClutterPoint *pos = g_value_get_boxed (value);
+        const graphene_point_t *pos = g_value_get_boxed (value);
 
         if (pos != NULL)
           clutter_actor_set_position (actor, pos->x, pos->y);
@@ -5079,7 +5066,7 @@ clutter_actor_set_property (GObject      *object,
 
     case PROP_SIZE:
       {
-        const ClutterSize *size = g_value_get_boxed (value);
+        const graphene_size_t *size = g_value_get_boxed (value);
 
         if (size != NULL)
           clutter_actor_set_size (actor, size->width, size->height);
@@ -5165,10 +5152,10 @@ clutter_actor_set_property (GObject      *object,
 
     case PROP_PIVOT_POINT:
       {
-        const ClutterPoint *pivot = g_value_get_boxed (value);
+        const graphene_point_t *pivot = g_value_get_boxed (value);
 
         if (pivot == NULL)
-          pivot = clutter_point_zero ();
+          pivot = graphene_point_zero ();
 
         clutter_actor_set_pivot_point (actor, pivot->x, pivot->y);
       }
@@ -5222,16 +5209,6 @@ clutter_actor_set_property (GObject      *object,
       clutter_actor_set_scale_gravity (actor, g_value_get_enum (value));
       break;
 
-    case PROP_CLIP: /* XXX:2.0 - remove */
-      {
-        const ClutterGeometry *geom = g_value_get_boxed (value);
-
-	clutter_actor_set_clip (actor,
-				geom->x, geom->y,
-				geom->width, geom->height);
-      }
-      break;
-
     case PROP_CLIP_RECT:
       clutter_actor_set_clip_rect (actor, g_value_get_boxed (value));
       break;
@@ -5424,11 +5401,11 @@ clutter_actor_get_property (GObject    *object,
 
     case PROP_POSITION:
       {
-        ClutterPoint position;
+        graphene_point_t position;
 
-        clutter_point_init (&position,
-                            clutter_actor_get_x (actor),
-                            clutter_actor_get_y (actor));
+        graphene_point_init (&position,
+                             clutter_actor_get_x (actor),
+                             clutter_actor_get_y (actor));
         g_value_set_boxed (value, &position);
       }
       break;
@@ -5443,11 +5420,11 @@ clutter_actor_get_property (GObject    *object,
 
     case PROP_SIZE:
       {
-        ClutterSize size;
+        graphene_size_t size;
 
-        clutter_size_init (&size,
-                           clutter_actor_get_width (actor),
-                           clutter_actor_get_height (actor));
+        graphene_size_init (&size,
+                            clutter_actor_get_width (actor),
+                            clutter_actor_get_height (actor));
         g_value_set_boxed (value, &size);
       }
       break;
@@ -5570,19 +5547,6 @@ clutter_actor_get_property (GObject    *object,
       g_value_set_boolean (value, priv->has_clip);
       break;
 
-    case PROP_CLIP: /* XXX:2.0 - remove */
-      {
-        ClutterGeometry clip;
-
-        clip.x      = CLUTTER_NEARBYINT (priv->clip.origin.x);
-        clip.y      = CLUTTER_NEARBYINT (priv->clip.origin.y);
-        clip.width  = CLUTTER_NEARBYINT (priv->clip.size.width);
-        clip.height = CLUTTER_NEARBYINT (priv->clip.size.height);
-
-        g_value_set_boxed (value, &clip);
-      }
-      break;
-
     case PROP_CLIP_RECT:
       g_value_set_boxed (value, &priv->clip);
       break;
@@ -5730,7 +5694,7 @@ clutter_actor_get_property (GObject    *object,
 
     case PROP_ROTATION_CENTER_X: /* XXX:2.0 - remove */
       {
-        ClutterVertex center;
+        graphene_point3d_t center;
 
         clutter_actor_get_rotation (actor, CLUTTER_X_AXIS,
                                     &center.x,
@@ -5743,7 +5707,7 @@ clutter_actor_get_property (GObject    *object,
 
     case PROP_ROTATION_CENTER_Y: /* XXX:2.0 - remove */
       {
-        ClutterVertex center;
+        graphene_point3d_t center;
 
         clutter_actor_get_rotation (actor, CLUTTER_Y_AXIS,
                                     &center.x,
@@ -5756,7 +5720,7 @@ clutter_actor_get_property (GObject    *object,
 
     case PROP_ROTATION_CENTER_Z: /* XXX:2.0 - remove */
       {
-        ClutterVertex center;
+        graphene_point3d_t center;
 
         clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS,
                                     &center.x,
@@ -6166,7 +6130,7 @@ clutter_actor_update_default_paint_volume (ClutterActor       *self,
           priv->clip.size.width >= 0 &&
           priv->clip.size.height >= 0)
         {
-          ClutterVertex origin;
+          graphene_point3d_t origin;
 
           origin.x = priv->clip.origin.x;
           origin.y = priv->clip.origin.y;
@@ -6442,7 +6406,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("position",
                         P_("Position"),
                         P_("The position of the origin of the actor"),
-                        CLUTTER_TYPE_POINT,
+                        GRAPHENE_TYPE_POINT,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         CLUTTER_PARAM_ANIMATABLE);
@@ -6501,7 +6465,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("size",
                         P_("Size"),
                         P_("The size of the actor"),
-                        CLUTTER_TYPE_SIZE,
+                        GRAPHENE_TYPE_SIZE,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         CLUTTER_PARAM_ANIMATABLE);
@@ -6943,25 +6907,11 @@ clutter_actor_class_init (ClutterActorClass *klass)
                           FALSE,
                           CLUTTER_PARAM_READABLE);
 
-  /**
-   * ClutterActor:clip:
-   *
-   * The visible region of the actor, in actor-relative coordinates
-   *
-   * Deprecated: 1.12: Use #ClutterActor:clip-rect instead.
-   */
-  obj_props[PROP_CLIP] = /* XXX:2.0 - remove */
-    g_param_spec_boxed ("clip",
-                        P_("Clip"),
-                        P_("The clip region for the actor"),
-                        CLUTTER_TYPE_GEOMETRY,
-                        CLUTTER_PARAM_READWRITE);
-
   /**
    * ClutterActor:clip-rect:
    *
    * The visible region of the actor, in actor-relative coordinates,
-   * expressed as a #ClutterRect.
+   * expressed as a #graphene_rect_t.
    *
    * Setting this property to %NULL will unset the existing clip.
    *
@@ -6974,7 +6924,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("clip-rect",
                         P_("Clip Rectangle"),
                         P_("The visible region of the actor"),
-                        CLUTTER_TYPE_RECT,
+                        GRAPHENE_TYPE_RECT,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS);
 
@@ -7011,7 +6961,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("pivot-point",
                         P_("Pivot Point"),
                         P_("The point around which the scaling and rotation occur"),
-                        CLUTTER_TYPE_POINT,
+                        GRAPHENE_TYPE_POINT,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         CLUTTER_PARAM_ANIMATABLE);
@@ -7233,7 +7183,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("rotation-center-x",
                         P_("Rotation Center X"),
                         P_("The rotation center on the X axis"),
-                        CLUTTER_TYPE_VERTEX,
+                        GRAPHENE_TYPE_POINT3D,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         G_PARAM_DEPRECATED);
@@ -7251,7 +7201,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("rotation-center-y",
                         P_("Rotation Center Y"),
                         P_("The rotation center on the Y axis"),
-                        CLUTTER_TYPE_VERTEX,
+                        GRAPHENE_TYPE_POINT3D,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         G_PARAM_DEPRECATED);
@@ -7269,7 +7219,7 @@ clutter_actor_class_init (ClutterActorClass *klass)
     g_param_spec_boxed ("rotation-center-z",
                         P_("Rotation Center Z"),
                         P_("The rotation center on the Z axis"),
-                        CLUTTER_TYPE_VERTEX,
+                        GRAPHENE_TYPE_POINT3D,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         G_PARAM_DEPRECATED);
@@ -8896,7 +8846,7 @@ _clutter_actor_queue_redraw_full (ClutterActor             *self,
   if (flags & CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION)
     {
       ClutterActorBox allocation_clip;
-      ClutterVertex origin;
+      graphene_point3d_t origin;
 
       /* If the actor doesn't have a valid allocation then we will
        * queue a full stage redraw. */
@@ -9100,7 +9050,7 @@ clutter_actor_queue_redraw_with_clip (ClutterActor                *self,
                                       const cairo_rectangle_int_t *clip)
 {
   ClutterPaintVolume volume;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
 
@@ -10324,17 +10274,17 @@ clutter_actor_set_position (ClutterActor *self,
 			    gfloat        x,
 			    gfloat        y)
 {
-  ClutterPoint new_position;
-  ClutterPoint cur_position;
+  graphene_point_t new_position;
+  graphene_point_t cur_position;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
 
-  clutter_point_init (&new_position, x, y);
+  graphene_point_init (&new_position, x, y);
 
   cur_position.x = clutter_actor_get_x (self);
   cur_position.y = clutter_actor_get_y (self);
 
-  if (!clutter_point_equals (&cur_position, &new_position))
+  if (!graphene_point_equal (&cur_position, &new_position))
     _clutter_actor_create_transition (self, obj_props[PROP_POSITION],
                                       &cur_position,
                                       &new_position);
@@ -10769,8 +10719,8 @@ clutter_actor_set_height_internal (ClutterActor *self,
 }
 
 static void
-clutter_actor_set_size_internal (ClutterActor      *self,
-                                 const ClutterSize *size)
+clutter_actor_set_size_internal (ClutterActor          *self,
+                                 const graphene_size_t *size)
 {
   if (size != NULL)
     {
@@ -10806,11 +10756,11 @@ clutter_actor_set_size (ClutterActor *self,
 			gfloat        width,
 			gfloat        height)
 {
-  ClutterSize new_size;
+  graphene_size_t new_size;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
 
-  clutter_size_init (&new_size, width, height);
+  graphene_size_init (&new_size, width, height);
 
   /* minor optimization: if we don't have a duration then we can
    * skip the get_size() below, to avoid the chance of going through
@@ -10829,11 +10779,11 @@ clutter_actor_set_size (ClutterActor *self,
     }
   else
     {
-      ClutterSize cur_size;
+      graphene_size_t cur_size;
 
-      clutter_size_init (&cur_size,
-                         clutter_actor_get_width (self),
-                         clutter_actor_get_height (self));
+      graphene_size_init (&cur_size,
+                          clutter_actor_get_width (self),
+                          clutter_actor_get_height (self));
 
       _clutter_actor_create_transition (self,
                                         obj_props[PROP_SIZE],
@@ -10919,8 +10869,8 @@ clutter_actor_get_transformed_position (ClutterActor *self,
                                         gfloat       *x,
                                         gfloat       *y)
 {
-  ClutterVertex v1;
-  ClutterVertex v2;
+  graphene_point3d_t v1;
+  graphene_point3d_t v2;
 
   v1.x = v1.y = v1.z = 0;
   clutter_actor_apply_transform_to_point (self, &v1, &v2);
@@ -10966,7 +10916,7 @@ clutter_actor_get_transformed_size (ClutterActor *self,
                                     gfloat       *height)
 {
   ClutterActorPrivate *priv;
-  ClutterVertex v[4];
+  graphene_point3d_t v[4];
   gfloat x_min, x_max, y_min, y_max;
   gint i;
 
@@ -11288,8 +11238,8 @@ clutter_actor_set_y_internal (ClutterActor *self,
 }
 
 static void
-clutter_actor_set_position_internal (ClutterActor       *self,
-                                     const ClutterPoint *position)
+clutter_actor_set_position_internal (ClutterActor           *self,
+                                     const graphene_point_t *position)
 {
   ClutterActorPrivate *priv = self->priv;
   ClutterLayoutInfo *linfo;
@@ -11298,7 +11248,7 @@ clutter_actor_set_position_internal (ClutterActor       *self,
   linfo = _clutter_actor_get_layout_info (self);
 
   if (priv->position_set &&
-      clutter_point_equals (position, &linfo->fixed_pos))
+      graphene_point_equal (position, &linfo->fixed_pos))
     return;
 
   clutter_actor_store_old_geometry (self, &old);
@@ -11383,8 +11333,7 @@ clutter_actor_set_y (ClutterActor *self,
  * the X coordinate of the origin of the allocation box.
  *
  * If the actor has any fixed coordinate set using clutter_actor_set_x(),
- * clutter_actor_set_position() or clutter_actor_set_geometry(), this
- * function will return that coordinate.
+ * clutter_actor_set_position(), this function will return that coordinate.
  *
  * If both the allocation and a fixed position are missing, this function
  * will return 0.
@@ -11431,8 +11380,7 @@ clutter_actor_get_x (ClutterActor *self)
  * the Y coordinate of the origin of the allocation box.
  *
  * If the actor has any fixed coordinate set using clutter_actor_set_y(),
- * clutter_actor_set_position() or clutter_actor_set_geometry(), this
- * function will return that coordinate.
+ * clutter_actor_set_position(), this function will return that coordinate.
  *
  * If both the allocation and a fixed position are missing, this function
  * will return 0.
@@ -12117,7 +12065,7 @@ clutter_actor_set_pivot_point (ClutterActor *self,
                                gfloat        pivot_x,
                                gfloat        pivot_y)
 {
-  ClutterPoint pivot = CLUTTER_POINT_INIT (pivot_x, pivot_y);
+  graphene_point_t pivot = GRAPHENE_POINT_INIT (pivot_x, pivot_y);
   const ClutterTransformInfo *info;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
@@ -12278,7 +12226,7 @@ clutter_actor_set_rotation (ClutterActor      *self,
                             gfloat             y,
                             gfloat             z)
 {
-  ClutterVertex v;
+  graphene_point3d_t v;
 
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
 
@@ -12475,7 +12423,6 @@ clutter_actor_set_clip (ClutterActor *self,
 
   clutter_actor_queue_redraw (self);
 
-  g_object_notify_by_pspec (obj, obj_props[PROP_CLIP]);
   g_object_notify_by_pspec (obj, obj_props[PROP_CLIP_RECT]);
   g_object_notify_by_pspec (obj, obj_props[PROP_HAS_CLIP]);
 }
@@ -15226,7 +15173,7 @@ clutter_actor_transform_stage_point (ClutterActor *self,
 				     gfloat       *x_out,
 				     gfloat       *y_out)
 {
-  ClutterVertex v[4];
+  graphene_point3d_t v[4];
   double ST[3][3];
   double RQ[3][3];
   int du, dv;
@@ -16209,17 +16156,6 @@ clutter_anchor_coord_set_gravity (AnchorCoord    *coord,
   coord->is_fractional = TRUE;
 }
 
-static gboolean
-clutter_anchor_coord_is_zero (const AnchorCoord *coord)
-{
-  if (coord->is_fractional)
-    return coord->v.fraction.x == 0.0 && coord->v.fraction.y == 0.0;
-  else
-    return (coord->v.units.x == 0.0
-            && coord->v.units.y == 0.0
-            && coord->v.units.z == 0.0);
-}
-
 /**
  * clutter_actor_get_flags:
  * @self: a #ClutterActor
@@ -17780,9 +17716,9 @@ clutter_actor_get_paint_box (ClutterActor    *self,
 }
 
 static gboolean
-_clutter_actor_get_resource_scale_for_rect (ClutterActor *self,
-                                            ClutterRect  *bounding_rect,
-                                            float        *resource_scale)
+_clutter_actor_get_resource_scale_for_rect (ClutterActor    *self,
+                                            graphene_rect_t *bounding_rect,
+                                            float           *resource_scale)
 {
   ClutterActor *stage;
   float max_scale = 0;
@@ -17805,7 +17741,7 @@ static gboolean
 _clutter_actor_compute_resource_scale (ClutterActor *self,
                                        float        *resource_scale)
 {
-  ClutterRect bounding_rect;
+  graphene_rect_t bounding_rect;
   ClutterActorPrivate *priv = self->priv;
 
   if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
@@ -18349,13 +18285,13 @@ clutter_actor_get_layout_manager (ClutterActor *self)
 }
 
 static const ClutterLayoutInfo default_layout_info = {
-  CLUTTER_POINT_INIT_ZERO,      /* fixed-pos */
+  GRAPHENE_POINT_INIT_ZERO,     /* fixed-pos */
   { 0, 0, 0, 0 },               /* margin */
   CLUTTER_ACTOR_ALIGN_FILL,     /* x-align */
   CLUTTER_ACTOR_ALIGN_FILL,     /* y-align */
   FALSE, FALSE,                 /* expand */
-  CLUTTER_SIZE_INIT_ZERO,       /* minimum */
-  CLUTTER_SIZE_INIT_ZERO,       /* natural */
+  GRAPHENE_SIZE_INIT_ZERO,       /* minimum */
+  GRAPHENE_SIZE_INIT_ZERO,       /* natural */
 };
 
 static void

clutter/clutter/clutter-actor.h

@@ -431,7 +431,7 @@ void                            clutter_actor_get_allocation_box
 CLUTTER_EXPORT
 void                            clutter_actor_get_allocation_vertices           (ClutterActor                *self,
                                                                                  ClutterActor                *ancestor,
-                                                                                 ClutterVertex                verts[]);
+                                                                                 graphene_point3d_t          *verts);
 CLUTTER_EXPORT
 gboolean                        clutter_actor_has_allocation                    (ClutterActor                *self);
 CLUTTER_EXPORT
@@ -817,16 +817,16 @@ gboolean                        clutter_actor_transform_stage_point
                                                                                  gfloat                     *y_out);
 CLUTTER_EXPORT
 void                            clutter_actor_get_abs_allocation_vertices       (ClutterActor               *self,
-                                                                                 ClutterVertex               verts[]);
+                                                                                 graphene_point3d_t         *verts);
 CLUTTER_EXPORT
 void                            clutter_actor_apply_transform_to_point          (ClutterActor               *self,
-                                                                                 const ClutterVertex        *point,
-                                                                                 ClutterVertex              *vertex);
+                                                                                 const graphene_point3d_t   *point,
+                                                                                 graphene_point3d_t         *vertex);
 CLUTTER_EXPORT
 void                            clutter_actor_apply_relative_transform_to_point (ClutterActor               *self,
                                                                                  ClutterActor               *ancestor,
-                                                                                 const ClutterVertex        *point,
-                                                                                 ClutterVertex              *vertex);
+                                                                                 const graphene_point3d_t   *point,
+                                                                                 graphene_point3d_t         *vertex);
 
 /* Implicit animations */
 CLUTTER_EXPORT

clutter/clutter/clutter-autocleanups.h

@@ -94,10 +94,6 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterMatrix, clutter_matrix_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPaintNode, clutter_paint_node_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPaintVolume, clutter_paint_volume_free)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPathNode, clutter_path_node_free)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterPoint, clutter_point_free)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterRect, clutter_rect_free)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterSize, clutter_size_free)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterVertex, clutter_vertex_free)
 
 #endif /* __GI_SCANNER__ */
 

clutter/clutter/clutter-bind-constraint.c

@@ -152,7 +152,9 @@ clutter_bind_constraint_update_allocation (ClutterConstraint *constraint,
   ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (constraint);
   gfloat source_width, source_height;
   gfloat actor_width, actor_height;
-  ClutterVertex source_position = { 0., };
+  graphene_point3d_t source_position;
+
+  source_position = GRAPHENE_POINT3D_INIT (0.f, 0.f, 0.f);
 
   if (bind->source == NULL)
     return;

clutter/clutter/clutter-blur-effect.c

@@ -182,7 +182,7 @@ clutter_blur_effect_get_paint_volume (ClutterEffect      *effect,
                                       ClutterPaintVolume *volume)
 {
   gfloat cur_width, cur_height;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
 
   clutter_paint_volume_get_origin (volume, &origin);
   cur_width = clutter_paint_volume_get_width (volume);

clutter/clutter/clutter-deform-effect.c

@@ -177,7 +177,7 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
 
   if (priv->is_dirty)
     {
-      ClutterRect rect;
+      graphene_rect_t rect;
       gboolean mapped_buffer;
       CoglVertexP3T2C4 *verts;
       ClutterActor *actor;
@@ -193,8 +193,8 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
        */
       if (clutter_offscreen_effect_get_target_rect (effect, &rect))
         {
-          width = clutter_rect_get_width (&rect);
-          height = clutter_rect_get_height (&rect);
+          width = graphene_rect_get_width (&rect);
+          height = graphene_rect_get_height (&rect);
         }
       else
         clutter_actor_get_size (actor, &width, &height);

clutter/clutter/clutter-drag-action.c

@@ -81,7 +81,7 @@ struct _ClutterDragActionPrivate
   gint y_drag_threshold;
   ClutterActor *drag_handle;
   ClutterDragAxis drag_axis;
-  ClutterRect drag_area;
+  graphene_rect_t drag_area;
 
   ClutterInputDevice *device;
   ClutterEventSequence *sequence;
@@ -542,7 +542,7 @@ clutter_drag_action_real_drag_motion (ClutterDragAction *action,
 
   if (action->priv->drag_area_set)
     {
-      ClutterRect *drag_area = &action->priv->drag_area;
+      graphene_rect_t *drag_area = &action->priv->drag_area;
 
       x = CLAMP (x, drag_area->origin.x, drag_area->origin.x + drag_area->size.width);
       y = CLAMP (y, drag_area->origin.y, drag_area->origin.y + drag_area->size.height);
@@ -811,7 +811,7 @@ clutter_drag_action_class_init (ClutterDragActionClass *klass)
     g_param_spec_boxed ("drag-area",
 			P_("Drag Area"),
 			P_("Constrains the dragging to a rectangle"),
-			CLUTTER_TYPE_RECT,
+			GRAPHENE_TYPE_RECT,
 			CLUTTER_PARAM_READWRITE);
 
   /**
@@ -1267,10 +1267,10 @@ clutter_drag_action_get_motion_coords (ClutterDragAction *action,
 /**
  * clutter_drag_action_get_drag_area:
  * @action: a #ClutterDragAction
- * @drag_area: (out caller-allocates): a #ClutterRect to be filled
+ * @drag_area: (out caller-allocates): a #graphene_rect_t to be filled
  *
  * Retrieves the "drag area" associated with @action, that
- * is a #ClutterRect that constrains the actor movements,
+ * is a #graphene_rect_t that constrains the actor movements,
  * in parents coordinates.
  *
  * Returns: %TRUE if the actor is actually constrained (and thus
@@ -1278,7 +1278,7 @@ clutter_drag_action_get_motion_coords (ClutterDragAction *action,
  */
 gboolean
 clutter_drag_action_get_drag_area (ClutterDragAction *action,
-				   ClutterRect       *drag_area)
+                                   graphene_rect_t   *drag_area)
 {
   g_return_val_if_fail (CLUTTER_IS_DRAG_ACTION (action), FALSE);
 
@@ -1298,8 +1298,8 @@ clutter_drag_action_get_drag_area (ClutterDragAction *action,
  * If @drag_area is %NULL, the actor is not constrained.
  */
 void
-clutter_drag_action_set_drag_area (ClutterDragAction *action,
-				   const ClutterRect *drag_area)
+clutter_drag_action_set_drag_area (ClutterDragAction     *action,
+                                   const graphene_rect_t *drag_area)
 {
   ClutterDragActionPrivate *priv;
 

clutter/clutter/clutter-drag-action.h

@@ -141,11 +141,11 @@ void            clutter_drag_action_get_motion_coords  (ClutterDragAction *actio
 
 CLUTTER_EXPORT
 gboolean        clutter_drag_action_get_drag_area      (ClutterDragAction *action,
-                                                        ClutterRect       *drag_area);
+                                                        graphene_rect_t   *drag_area);
 
 CLUTTER_EXPORT
-void            clutter_drag_action_set_drag_area      (ClutterDragAction *action,
-                                                        const ClutterRect *drag_area);
+void            clutter_drag_action_set_drag_area      (ClutterDragAction     *action,
+                                                        const graphene_rect_t *drag_area);
 
 G_END_DECLS
 

clutter/clutter/clutter-event.c

@@ -370,7 +370,7 @@ clutter_event_get_coords (const ClutterEvent *event,
                           gfloat             *x,
                           gfloat             *y)
 {
-  ClutterPoint coords;
+  graphene_point_t coords;
 
   g_return_if_fail (event != NULL);
 
@@ -386,15 +386,15 @@ clutter_event_get_coords (const ClutterEvent *event,
 /**
  * clutter_event_get_position:
  * @event: a #ClutterEvent
- * @position: a #ClutterPoint
+ * @position: a #graphene_point_t
  *
- * Retrieves the event coordinates as a #ClutterPoint.
+ * Retrieves the event coordinates as a #graphene_point_t.
  *
  * Since: 1.12
  */
 void
 clutter_event_get_position (const ClutterEvent *event,
-                            ClutterPoint       *position)
+                            graphene_point_t   *position)
 {
   g_return_if_fail (event != NULL);
   g_return_if_fail (position != NULL);
@@ -415,42 +415,42 @@ clutter_event_get_position (const ClutterEvent *event,
     case CLUTTER_PAD_BUTTON_RELEASE:
     case CLUTTER_PAD_STRIP:
     case CLUTTER_PAD_RING:
-      clutter_point_init (position, 0.f, 0.f);
+      graphene_point_init (position, 0.f, 0.f);
       break;
 
     case CLUTTER_ENTER:
     case CLUTTER_LEAVE:
-      clutter_point_init (position, event->crossing.x, event->crossing.y);
+      graphene_point_init (position, event->crossing.x, event->crossing.y);
       break;
 
     case CLUTTER_BUTTON_PRESS:
     case CLUTTER_BUTTON_RELEASE:
-      clutter_point_init (position, event->button.x, event->button.y);
+      graphene_point_init (position, event->button.x, event->button.y);
       break;
 
     case CLUTTER_MOTION:
-      clutter_point_init (position, event->motion.x, event->motion.y);
+      graphene_point_init (position, event->motion.x, event->motion.y);
       break;
 
     case CLUTTER_TOUCH_BEGIN:
     case CLUTTER_TOUCH_UPDATE:
     case CLUTTER_TOUCH_END:
     case CLUTTER_TOUCH_CANCEL:
-      clutter_point_init (position, event->touch.x, event->touch.y);
+      graphene_point_init (position, event->touch.x, event->touch.y);
       break;
 
     case CLUTTER_SCROLL:
-      clutter_point_init (position, event->scroll.x, event->scroll.y);
+      graphene_point_init (position, event->scroll.x, event->scroll.y);
       break;
 
     case CLUTTER_TOUCHPAD_PINCH:
-      clutter_point_init (position, event->touchpad_pinch.x,
-                          event->touchpad_pinch.y);
+      graphene_point_init (position, event->touchpad_pinch.x,
+                           event->touchpad_pinch.y);
       break;
 
     case CLUTTER_TOUCHPAD_SWIPE:
-      clutter_point_init (position, event->touchpad_swipe.x,
-                          event->touchpad_swipe.y);
+      graphene_point_init (position, event->touchpad_swipe.x,
+                           event->touchpad_swipe.y);
       break;
     }
 
@@ -1793,12 +1793,12 @@ float
 clutter_event_get_distance (const ClutterEvent *source,
                             const ClutterEvent *target)
 {
-  ClutterPoint p0, p1;
+  graphene_point_t p0, p1;
 
   clutter_event_get_position (source, &p0);
   clutter_event_get_position (source, &p1);
 
-  return clutter_point_distance (&p0, &p1, NULL, NULL);
+  return graphene_point_distance (&p0, &p1, NULL, NULL);
 }
 
 /**
@@ -1819,17 +1819,17 @@ double
 clutter_event_get_angle (const ClutterEvent *source,
                          const ClutterEvent *target)
 {
-  ClutterPoint p0, p1;
+  graphene_point_t p0, p1;
   float x_distance, y_distance;
   double angle;
 
   clutter_event_get_position (source, &p0);
   clutter_event_get_position (target, &p1);
 
-  if (clutter_point_equals (&p0, &p1))
+  if (graphene_point_equal (&p0, &p1))
     return 0;
 
-  clutter_point_distance (&p0, &p1, &x_distance, &y_distance);
+  graphene_point_distance (&p0, &p1, &x_distance, &y_distance);
 
   angle = atan2 (x_distance, y_distance);
 

clutter/clutter/clutter-event.h

@@ -685,7 +685,7 @@ void                    clutter_event_get_coords                (const ClutterEv
                                                                  gfloat                 *y);
 CLUTTER_EXPORT
 void                    clutter_event_get_position              (const ClutterEvent     *event,
-                                                                 ClutterPoint           *position);
+                                                                 graphene_point_t       *position);
 CLUTTER_EXPORT
 float                   clutter_event_get_distance              (const ClutterEvent     *source,
                                                                  const ClutterEvent     *target);

clutter/clutter/clutter-graphene.c

@@ -0,0 +1,108 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * Copyright (C) 2019 Endless, Inc
+ * Copyright (C) 2009, 2010 Intel Corp
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "clutter-graphene.h"
+#include "clutter-private.h"
+#include "clutter-types.h"
+
+static gboolean
+graphene_point_progress (const GValue *a,
+                         const GValue *b,
+                         gdouble       progress,
+                         GValue       *retval)
+{
+  const graphene_point_t *ap = g_value_get_boxed (a);
+  const graphene_point_t *bp = g_value_get_boxed (b);
+  graphene_point_t res;
+
+  graphene_point_interpolate (ap, bp, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_point3d_progress (const GValue *a,
+                           const GValue *b,
+                           gdouble       progress,
+                           GValue       *retval)
+{
+  const graphene_point3d_t *av = g_value_get_boxed (a);
+  const graphene_point3d_t *bv = g_value_get_boxed (b);
+  graphene_point3d_t res;
+
+  graphene_point3d_interpolate (av, bv, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_rect_progress (const GValue *a,
+                        const GValue *b,
+                        gdouble       progress,
+                        GValue       *retval)
+{
+  const graphene_rect_t *rect_a = g_value_get_boxed (a);
+  const graphene_rect_t *rect_b = g_value_get_boxed (b);
+  graphene_rect_t res;
+
+  graphene_rect_interpolate (rect_a, rect_b, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+static gboolean
+graphene_size_progress (const GValue *a,
+                        const GValue *b,
+                        gdouble       progress,
+                        GValue       *retval)
+{
+  const graphene_size_t *as = g_value_get_boxed (a);
+  const graphene_size_t *bs = g_value_get_boxed (b);
+  graphene_size_t res;
+
+  graphene_size_interpolate (as, bs, progress, &res);
+
+  g_value_set_boxed (retval, &res);
+
+  return TRUE;
+}
+
+void
+clutter_graphene_init (void)
+{
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT,
+                                           graphene_point_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT3D,
+                                           graphene_point3d_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_RECT,
+                                           graphene_rect_progress);
+  clutter_interval_register_progress_func (GRAPHENE_TYPE_SIZE,
+                                           graphene_size_progress);
+}

clutter/clutter/clutter-graphene.h

@@ -0,0 +1,30 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
+ *
+ * Copyright (C) 2019 Endless, Inc
+ * Copyright (C) 2009, 2010 Intel Corp
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CLUTTER_GRAPHENE_H
+#define CLUTTER_GRAPHENE_H
+
+void clutter_graphene_init (void);
+
+#endif

clutter/clutter/clutter-input-device.c

@@ -986,7 +986,7 @@ clutter_input_device_get_enabled (ClutterInputDevice *device)
 gboolean
 clutter_input_device_get_coords (ClutterInputDevice   *device,
                                  ClutterEventSequence *sequence,
-                                 ClutterPoint         *point)
+                                 graphene_point_t     *point)
 {
   g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE (device), FALSE);
   g_return_val_if_fail (point != NULL, FALSE);
@@ -1033,7 +1033,9 @@ _clutter_input_device_update (ClutterInputDevice   *device,
   ClutterStage *stage;
   ClutterActor *new_cursor_actor;
   ClutterActor *old_cursor_actor;
-  ClutterPoint point = { -1, -1 };
+  graphene_point_t point;
+
+  point = GRAPHENE_POINT_INIT (-1.0f, -1.0f);
 
   if (device->device_type == CLUTTER_KEYBOARD_DEVICE)
     return NULL;

clutter/clutter/clutter-input-device.h

@@ -58,7 +58,7 @@ gint                    clutter_input_device_get_device_id      (ClutterInputDev
 CLUTTER_EXPORT
 gboolean                clutter_input_device_get_coords        (ClutterInputDevice   *device,
                                                                 ClutterEventSequence *sequence,
-                                                                ClutterPoint         *point);
+                                                                graphene_point_t     *point);
 CLUTTER_EXPORT
 ClutterModifierType     clutter_input_device_get_modifier_state (ClutterInputDevice  *device);
 CLUTTER_EXPORT

clutter/clutter/clutter-input-focus.c

@@ -89,8 +89,8 @@ clutter_input_focus_reset (ClutterInputFocus *focus)
 }
 
 void
-clutter_input_focus_set_cursor_location (ClutterInputFocus *focus,
-                                         const ClutterRect *rect)
+clutter_input_focus_set_cursor_location (ClutterInputFocus     *focus,
+                                         const graphene_rect_t *rect)
 {
   ClutterInputFocusPrivate *priv;
 

clutter/clutter/clutter-input-focus.h

@@ -57,8 +57,8 @@ gboolean clutter_input_focus_is_focused (ClutterInputFocus *focus);
 CLUTTER_EXPORT
 void clutter_input_focus_reset (ClutterInputFocus *focus);
 CLUTTER_EXPORT
-void clutter_input_focus_set_cursor_location (ClutterInputFocus *focus,
-                                              const ClutterRect *rect);
+void clutter_input_focus_set_cursor_location (ClutterInputFocus     *focus,
+                                              const graphene_rect_t *rect);
 
 CLUTTER_EXPORT
 void clutter_input_focus_set_surrounding (ClutterInputFocus *focus,

clutter/clutter/clutter-input-method-private.h

@@ -26,8 +26,8 @@ ClutterInputFocus * clutter_input_method_get_focus (ClutterInputMethod *method);
 
 void clutter_input_method_reset               (ClutterInputMethod *method);
 
-void clutter_input_method_set_cursor_location (ClutterInputMethod *method,
-                                               const ClutterRect  *rect);
+void clutter_input_method_set_cursor_location (ClutterInputMethod    *method,
+                                               const graphene_rect_t *rect);
 void clutter_input_method_set_surrounding     (ClutterInputMethod *method,
                                                const gchar        *text,
                                                guint               cursor,

clutter/clutter/clutter-input-method.c

@@ -187,7 +187,7 @@ clutter_input_method_class_init (ClutterInputMethodClass *klass)
                   G_TYPE_FROM_CLASS (object_class),
                   G_SIGNAL_RUN_LAST,
                   0, NULL, NULL, NULL,
-                  G_TYPE_NONE, 1, CLUTTER_TYPE_RECT);
+                  G_TYPE_NONE, 1, GRAPHENE_TYPE_RECT);
 
   pspecs[PROP_CONTENT_HINTS] =
     g_param_spec_flags ("content-hints",
@@ -377,8 +377,8 @@ clutter_input_method_reset (ClutterInputMethod *im)
 }
 
 void
-clutter_input_method_set_cursor_location (ClutterInputMethod *im,
-                                          const ClutterRect  *rect)
+clutter_input_method_set_cursor_location (ClutterInputMethod    *im,
+                                          const graphene_rect_t *rect)
 {
   g_return_if_fail (CLUTTER_IS_INPUT_METHOD (im));
 

clutter/clutter/clutter-input-method.h

@@ -42,8 +42,8 @@ struct _ClutterInputMethodClass
 
   void (* reset) (ClutterInputMethod *im);
 
-  void (* set_cursor_location) (ClutterInputMethod          *im,
-                                const ClutterRect           *rect);
+  void (* set_cursor_location) (ClutterInputMethod    *im,
+                                const graphene_rect_t *rect);
   void (* set_surrounding) (ClutterInputMethod *im,
                             const gchar        *text,
                             guint               cursor,

clutter/clutter/clutter-main.c

@@ -58,6 +58,7 @@
 #include "clutter-device-manager-private.h"
 #include "clutter-event-private.h"
 #include "clutter-feature.h"
+#include "clutter-graphene.h"
 #include "clutter-main.h"
 #include "clutter-master-clock.h"
 #include "clutter-mutter.h"
@@ -2574,6 +2575,8 @@ clutter_base_init (void)
 
       /* initialise the Big Clutter Lock™ if necessary */
       clutter_threads_init_default ();
+
+      clutter_graphene_init ();
     }
 }
 

clutter/clutter/clutter-offscreen-effect.c

@@ -86,7 +86,7 @@ struct _ClutterOffscreenEffectPrivate
   ClutterActor *actor;
   ClutterActor *stage;
 
-  ClutterVertex position;
+  graphene_point3d_t position;
 
   int fbo_offset_x;
   int fbo_offset_y;
@@ -250,9 +250,11 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
   gfloat target_width = -1, target_height = -1;
   gfloat resource_scale;
   gfloat ceiled_resource_scale;
-  ClutterVertex local_offset = { 0.f, 0.f, 0.f };
+  graphene_point3d_t local_offset;
   gfloat old_viewport[4];
 
+  local_offset = GRAPHENE_POINT3D_INIT (0.0f, 0.0f, 0.0f);
+
   if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)))
     return FALSE;
 
@@ -323,7 +325,7 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
    * contents on screen...
    */
   clutter_actor_get_transform (priv->stage, &modelview);
-  cogl_set_modelview_matrix (&modelview);
+  cogl_framebuffer_set_modelview_matrix (priv->offscreen, &modelview);
 
   /* Save the original viewport for calculating priv->position */
   _clutter_stage_get_viewport (CLUTTER_STAGE (priv->stage),
@@ -335,10 +337,11 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
   /* Set up the viewport so that it has the same size as the stage (avoid
    * distortion), but translated to account for the FBO offset...
    */
-  cogl_set_viewport (-priv->fbo_offset_x,
-                     -priv->fbo_offset_y,
-                     stage_width,
-                     stage_height);
+  cogl_framebuffer_set_viewport (priv->offscreen,
+                                 -priv->fbo_offset_x,
+                                 -priv->fbo_offset_y,
+                                 stage_width,
+                                 stage_height);
 
   /* Copy the stage's projection matrix across to the framebuffer */
   _clutter_stage_get_projection_matrix (CLUTTER_STAGE (priv->stage),
@@ -355,14 +358,15 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect)
                                           &priv->position,
                                           1);
 
-  cogl_set_projection_matrix (&projection);
+  cogl_framebuffer_set_projection_matrix (priv->offscreen, &projection);
 
   cogl_color_init_from_4ub (&transparent, 0, 0, 0, 0);
-  cogl_clear (&transparent,
-              COGL_BUFFER_BIT_COLOR |
-              COGL_BUFFER_BIT_DEPTH);
+  cogl_framebuffer_clear (priv->offscreen,
+                          COGL_BUFFER_BIT_COLOR |
+                          COGL_BUFFER_BIT_DEPTH,
+                          &transparent);
 
-  cogl_push_matrix ();
+  cogl_framebuffer_push_matrix (priv->offscreen);
 
   /* Override the actor's opacity to fully opaque - we paint the offscreen
    * texture with the actor's paint opacity, so we need to do this to avoid
@@ -408,15 +412,16 @@ static void
 clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect)
 {
   ClutterOffscreenEffectPrivate *priv = effect->priv;
+  CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   CoglMatrix modelview;
   float resource_scale;
 
-  cogl_push_matrix ();
+  cogl_framebuffer_push_matrix (framebuffer);
 
   /* The current modelview matrix is *almost* perfect already. It's only
    * missing a correction for the expanded FBO and offset rendering within...
    */
-  cogl_get_modelview_matrix (&modelview);
+  cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview);
 
   if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) &&
       resource_scale != 1.0f)
@@ -429,14 +434,15 @@ clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect)
                          priv->fbo_offset_x,
                          priv->fbo_offset_y,
                          0.0f);
-  cogl_set_modelview_matrix (&modelview);
+
+  cogl_framebuffer_set_modelview_matrix (framebuffer, &modelview);
 
   /* paint the target material; this is virtualized for
    * sub-classes that require special hand-holding
    */
   clutter_offscreen_effect_paint_target (effect);
 
-  cogl_pop_matrix ();
+  cogl_framebuffer_pop_matrix (framebuffer);
 }
 
 static void
@@ -453,7 +459,7 @@ clutter_offscreen_effect_post_paint (ClutterEffect *effect)
   /* Restore the previous opacity override */
   clutter_actor_set_opacity_override (priv->actor, priv->old_opacity_override);
 
-  cogl_pop_matrix ();
+  cogl_framebuffer_pop_matrix (priv->offscreen);
   cogl_pop_framebuffer ();
 
   clutter_offscreen_effect_paint_texture (self);
@@ -682,7 +688,7 @@ clutter_offscreen_effect_get_target_size (ClutterOffscreenEffect *effect,
  */
 gboolean
 clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
-                                          ClutterRect            *rect)
+                                          graphene_rect_t        *rect)
 {
   ClutterOffscreenEffectPrivate *priv;
 
@@ -694,11 +700,11 @@ clutter_offscreen_effect_get_target_rect (ClutterOffscreenEffect *effect,
   if (priv->texture == NULL)
     return FALSE;
 
-  clutter_rect_init (rect,
-                     priv->position.x,
-                     priv->position.y,
-                     cogl_texture_get_width (priv->texture),
-                     cogl_texture_get_height (priv->texture));
+  graphene_rect_init (rect,
+                      priv->position.x,
+                      priv->position.y,
+                      cogl_texture_get_width (priv->texture),
+                      cogl_texture_get_height (priv->texture));
 
   return TRUE;
 }

clutter/clutter/clutter-offscreen-effect.h

@@ -114,7 +114,7 @@ gboolean        clutter_offscreen_effect_get_target_size        (ClutterOffscree
 
 CLUTTER_EXPORT
 gboolean        clutter_offscreen_effect_get_target_rect        (ClutterOffscreenEffect *effect,
-                                                                 ClutterRect            *rect);
+                                                                 graphene_rect_t        *rect);
 
 G_END_DECLS
 

clutter/clutter/clutter-paint-volume-private.h

@@ -58,7 +58,7 @@ struct _ClutterPaintVolume
    * elements 4, 5, 6 and 7 most of the time for 2D actors when
    * calculating the projected paint box.
    */
-  ClutterVertex vertices[8];
+  graphene_point3d_t vertices[8];
 
   /* As an optimization for internally managed PaintVolumes we allow
    * initializing ClutterPaintVolume variables allocated on the stack

clutter/clutter/clutter-paint-volume.c

@@ -63,7 +63,7 @@ _clutter_paint_volume_new (ClutterActor *actor)
 
   pv->actor = actor;
 
-  memset (pv->vertices, 0, 8 * sizeof (ClutterVertex));
+  memset (pv->vertices, 0, 8 * sizeof (graphene_point3d_t));
 
   pv->is_static = FALSE;
   pv->is_empty = TRUE;
@@ -96,7 +96,7 @@ _clutter_paint_volume_init_static (ClutterPaintVolume *pv,
 {
   pv->actor = actor;
 
-  memset (pv->vertices, 0, 8 * sizeof (ClutterVertex));
+  memset (pv->vertices, 0, 8 * sizeof (graphene_point3d_t));
 
   pv->is_static = TRUE;
   pv->is_empty = TRUE;
@@ -170,7 +170,7 @@ clutter_paint_volume_free (ClutterPaintVolume *pv)
 /**
  * clutter_paint_volume_set_origin:
  * @pv: a #ClutterPaintVolume
- * @origin: a #ClutterVertex
+ * @origin: a #graphene_point3d_t
  *
  * Sets the origin of the paint volume.
  *
@@ -183,7 +183,7 @@ clutter_paint_volume_free (ClutterPaintVolume *pv)
  */
 void
 clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
-                                 const ClutterVertex *origin)
+                                 const graphene_point3d_t *origin)
 {
   static const int key_vertices[4] = { 0, 1, 3, 4 };
   float dx, dy, dz;
@@ -210,7 +210,7 @@ clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
 /**
  * clutter_paint_volume_get_origin:
  * @pv: a #ClutterPaintVolume
- * @vertex: (out): the return location for a #ClutterVertex
+ * @vertex: (out): the return location for a #graphene_point3d_t
  *
  * Retrieves the origin of the #ClutterPaintVolume.
  *
@@ -218,7 +218,7 @@ clutter_paint_volume_set_origin (ClutterPaintVolume  *pv,
  */
 void
 clutter_paint_volume_get_origin (const ClutterPaintVolume *pv,
-                                 ClutterVertex            *vertex)
+                                 graphene_point3d_t       *vertex)
 {
   g_return_if_fail (pv != NULL);
   g_return_if_fail (vertex != NULL);
@@ -659,7 +659,7 @@ clutter_paint_volume_union_box (ClutterPaintVolume    *pv,
                                 const ClutterActorBox *box)
 {
   ClutterPaintVolume volume;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
 
   g_return_if_fail (pv != NULL);
   g_return_if_fail (box != NULL);
@@ -757,7 +757,7 @@ _clutter_paint_volume_get_bounding_box (ClutterPaintVolume *pv,
                                         ClutterActorBox *box)
 {
   gfloat x_min, y_min, x_max, y_max;
-  ClutterVertex *vertices;
+  graphene_point3d_t *vertices;
   int count;
   gint i;
 
@@ -878,9 +878,9 @@ _clutter_paint_volume_transform (ClutterPaintVolume *pv,
 
   cogl_matrix_transform_points (matrix,
                                 3,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                 pv->vertices,
-                                sizeof (ClutterVertex),
+                                sizeof (graphene_point3d_t),
                                 pv->vertices,
                                 transform_count);
 
@@ -896,7 +896,7 @@ _clutter_paint_volume_axis_align (ClutterPaintVolume *pv)
 {
   int count;
   int i;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
   float max_x;
   float max_y;
   float max_z;
@@ -1075,7 +1075,7 @@ _clutter_paint_volume_cull (ClutterPaintVolume *pv,
                             const ClutterPlane *planes)
 {
   int vertex_count;
-  ClutterVertex *vertices = pv->vertices;
+  graphene_point3d_t *vertices = pv->vertices;
   gboolean partial = FALSE;
   int i;
   int j;
@@ -1097,24 +1097,18 @@ _clutter_paint_volume_cull (ClutterPaintVolume *pv,
 
   for (i = 0; i < 4; i++)
     {
+      const ClutterPlane *plane = &planes[i];
       int out = 0;
       for (j = 0; j < vertex_count; j++)
         {
-          ClutterVertex p;
-          float distance;
+          graphene_vec3_t v;
 
-          /* XXX: for perspective projections this can be optimized
-           * out because all the planes should pass through the origin
-           * so (0,0,0) is a valid v0. */
-          p.x = vertices[j].x - planes[i].v0[0];
-          p.y = vertices[j].y - planes[i].v0[1];
-          p.z = vertices[j].z - planes[i].v0[2];
+          graphene_vec3_init (&v,
+                              vertices[j].x - graphene_vec3_get_x (&plane->v0),
+                              vertices[j].y - graphene_vec3_get_y (&plane->v0),
+                              vertices[j].z - graphene_vec3_get_z (&plane->v0));
 
-          distance = (planes[i].n[0] * p.x +
-                      planes[i].n[1] * p.y +
-                      planes[i].n[2] * p.z);
-
-          if (distance < 0)
+          if (graphene_vec3_dot (&plane->n, &v) < 0)
             out++;
         }
 

clutter/clutter/clutter-private.h

@@ -239,17 +239,17 @@ void _clutter_run_repaint_functions (ClutterRepaintFlags flags);
 
 GType _clutter_layout_manager_get_child_meta_type (ClutterLayoutManager *manager);
 
-void  _clutter_util_fully_transform_vertices (const CoglMatrix    *modelview,
-                                              const CoglMatrix    *projection,
-                                              const float         *viewport,
-                                              const ClutterVertex *vertices_in,
-                                              ClutterVertex       *vertices_out,
-                                              int                  n_vertices);
+void  _clutter_util_fully_transform_vertices (const CoglMatrix         *modelview,
+                                              const CoglMatrix         *projection,
+                                              const float              *viewport,
+                                              const graphene_point3d_t *vertices_in,
+                                              graphene_point3d_t       *vertices_out,
+                                              int                       n_vertices);
 
 void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
-                                        ClutterRect                 *dest);
+                                        graphene_rect_t             *dest);
 
-void _clutter_util_rectangle_int_extents (const ClutterRect     *src,
+void _clutter_util_rectangle_int_extents (const graphene_rect_t *src,
                                           cairo_rectangle_int_t *dest);
 
 void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
@@ -274,12 +274,6 @@ struct _ClutterVertex4
   float w;
 };
 
-void
-_clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
-                                   const ClutterVertex4 *b,
-                                   double                progress,
-                                   ClutterVertex4       *res);
-
 #define CLUTTER_MATRIX_INIT_IDENTITY { \
   1.0f, 0.0f, 0.0f, 0.0f, \
   0.0f, 1.0f, 0.0f, 0.0f, \
@@ -287,26 +281,10 @@ _clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
   0.0f, 0.0f, 0.0f, 1.0f, \
 }
 
-float   _clutter_util_matrix_determinant        (const ClutterMatrix *matrix);
-
-void    _clutter_util_matrix_skew_xy            (ClutterMatrix *matrix,
-                                                 float          factor);
-void    _clutter_util_matrix_skew_xz            (ClutterMatrix *matrix,
-                                                 float          factor);
-void    _clutter_util_matrix_skew_yz            (ClutterMatrix *matrix,
-                                                 float          factor);
-
-gboolean        _clutter_util_matrix_decompose  (const ClutterMatrix *src,
-                                                 ClutterVertex       *scale_p,
-                                                 float                shear_p[3],
-                                                 ClutterVertex       *rotate_p,
-                                                 ClutterVertex       *translate_p,
-                                                 ClutterVertex4      *perspective_p);
-
 typedef struct _ClutterPlane
 {
-  float v0[3];
-  float n[3];
+  graphene_vec3_t v0;
+  graphene_vec3_t n;
 } ClutterPlane;
 
 typedef enum _ClutterCullResult

clutter/clutter/clutter-script-parser.c

@@ -352,63 +352,64 @@ _clutter_script_parse_knot (ClutterScript *script,
 }
 
 static gboolean
-parse_geometry_from_array (JsonArray       *array,
-                           ClutterGeometry *geometry)
+parse_rect_from_array (JsonArray       *array,
+                       graphene_rect_t *rect)
 {
   if (json_array_get_length (array) != 4)
     return FALSE;
 
-  geometry->x = json_array_get_int_element (array, 0);
-  geometry->y = json_array_get_int_element (array, 1);
-  geometry->width = json_array_get_int_element (array, 2);
-  geometry->height = json_array_get_int_element (array, 3);
+  graphene_rect_init (rect,
+                      json_array_get_int_element (array, 0),
+                      json_array_get_int_element (array, 1),
+                      json_array_get_int_element (array, 2),
+                      json_array_get_int_element (array, 3));
 
   return TRUE;
 }
 
 static gboolean
-parse_geometry_from_object (JsonObject      *object,
-                            ClutterGeometry *geometry)
+parse_rect_from_object (JsonObject      *object,
+                            graphene_rect_t *rect)
 {
   if (json_object_has_member (object, "x"))
-    geometry->x = json_object_get_int_member (object, "x");
+    rect->origin.x = json_object_get_int_member (object, "x");
   else
-    geometry->x = 0;
+    rect->origin.x = 0;
 
   if (json_object_has_member (object, "y"))
-    geometry->y = json_object_get_int_member (object, "y");
+    rect->origin.y = json_object_get_int_member (object, "y");
   else
-    geometry->y = 0;
+    rect->origin.y = 0;
 
   if (json_object_has_member (object, "width"))
-    geometry->width = json_object_get_int_member (object, "width");
+    rect->size.width = json_object_get_int_member (object, "width");
   else
-    geometry->width = 0;
+    rect->size.width = 0;
 
   if (json_object_has_member (object, "height"))
-    geometry->height = json_object_get_int_member (object, "height");
+    rect->size.height = json_object_get_int_member (object, "height");
   else
-    geometry->height = 0;
+    rect->size.height = 0;
 
   return TRUE;
 }
 
 gboolean
-_clutter_script_parse_geometry (ClutterScript   *script,
-                                JsonNode        *node,
-                                ClutterGeometry *geometry)
+_clutter_script_parse_rect (ClutterScript   *script,
+                            JsonNode        *node,
+                            graphene_rect_t *rect)
 {
   g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
-  g_return_val_if_fail (geometry != NULL, FALSE);
+  g_return_val_if_fail (rect != NULL, FALSE);
 
   switch (JSON_NODE_TYPE (node))
     {
     case JSON_NODE_ARRAY:
-      return parse_geometry_from_array (json_node_get_array (node), geometry);
+      return parse_rect_from_array (json_node_get_array (node), rect);
 
     case JSON_NODE_OBJECT:
-      return parse_geometry_from_object (json_node_get_object (node), geometry);
+      return parse_rect_from_object (json_node_get_object (node), rect);
 
     default:
       break;
@@ -492,8 +493,8 @@ _clutter_script_parse_color (ClutterScript *script,
 }
 
 static gboolean
-parse_point_from_array (JsonArray    *array,
-                        ClutterPoint *point)
+parse_point_from_array (JsonArray        *array,
+                        graphene_point_t *point)
 {
   if (json_array_get_length (array) != 2)
     return FALSE;
@@ -505,8 +506,8 @@ parse_point_from_array (JsonArray    *array,
 }
 
 static gboolean
-parse_point_from_object (JsonObject   *object,
-                         ClutterPoint *point)
+parse_point_from_object (JsonObject       *object,
+                         graphene_point_t *point)
 {
   if (json_object_has_member (object, "x"))
     point->x = json_object_get_double_member (object, "x");
@@ -522,9 +523,9 @@ parse_point_from_object (JsonObject   *object,
 }
 
 gboolean
-_clutter_script_parse_point (ClutterScript *script,
-                             JsonNode      *node,
-                             ClutterPoint  *point)
+_clutter_script_parse_point (ClutterScript    *script,
+                             JsonNode         *node,
+                             graphene_point_t *point)
 {
   g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
@@ -546,8 +547,8 @@ _clutter_script_parse_point (ClutterScript *script,
 }
 
 static gboolean
-parse_size_from_array (JsonArray   *array,
-                       ClutterSize *size)
+parse_size_from_array (JsonArray       *array,
+                       graphene_size_t *size)
 {
   if (json_array_get_length (array) != 2)
     return FALSE;
@@ -559,8 +560,8 @@ parse_size_from_array (JsonArray   *array,
 }
 
 static gboolean
-parse_size_from_object (JsonObject  *object,
-                        ClutterSize *size)
+parse_size_from_object (JsonObject      *object,
+                        graphene_size_t *size)
 {
   if (json_object_has_member (object, "width"))
     size->width = json_object_get_double_member (object, "width");
@@ -576,9 +577,9 @@ parse_size_from_object (JsonObject  *object,
 }
 
 gboolean
-_clutter_script_parse_size (ClutterScript *script,
-                            JsonNode      *node,
-                            ClutterSize   *size)
+_clutter_script_parse_size (ClutterScript   *script,
+                            JsonNode        *node,
+                            graphene_size_t *size)
 {
   g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
@@ -1328,11 +1329,11 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (p_type == CLUTTER_TYPE_GEOMETRY)
+          else if (p_type == GRAPHENE_TYPE_RECT)
             {
-              ClutterGeometry geom = { 0, };
+              graphene_rect_t rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);
 
-              /* geometry := {
+              /* rect := {
                *        "x" : (int),
                *        "y" : (int),
                *        "width" : (int),
@@ -1340,9 +1341,9 @@ _clutter_script_parse_node (ClutterScript *script,
                * }
                */
 
-              if (_clutter_script_parse_geometry (script, node, &geom))
+              if (_clutter_script_parse_rect (script, node, &rect))
                 {
-                  g_value_set_boxed (value, &geom);
+                  g_value_set_boxed (value, &rect);
                   return TRUE;
                 }
             }
@@ -1364,9 +1365,9 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (p_type == CLUTTER_TYPE_POINT)
+          else if (p_type == GRAPHENE_TYPE_POINT)
             {
-              ClutterPoint point = CLUTTER_POINT_INIT_ZERO;
+              graphene_point_t point = GRAPHENE_POINT_INIT_ZERO;
 
               if (_clutter_script_parse_point (script, node, &point))
                 {
@@ -1374,9 +1375,9 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (p_type == CLUTTER_TYPE_SIZE)
+          else if (p_type == GRAPHENE_TYPE_SIZE)
             {
-              ClutterSize size = CLUTTER_SIZE_INIT_ZERO;
+              graphene_size_t size = GRAPHENE_SIZE_INIT_ZERO;
 
               if (_clutter_script_parse_size (script, node, &size))
                 {
@@ -1417,15 +1418,15 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_GEOMETRY))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_RECT))
             {
-              ClutterGeometry geom = { 0, };
+              graphene_rect_t rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);
 
-              /* geometry := [ (int), (int), (int), (int) ] */
+              /* rect := [ (int), (int), (int), (int) ] */
 
-              if (_clutter_script_parse_geometry (script, node, &geom))
+              if (_clutter_script_parse_rect (script, node, &rect))
                 {
-                  g_value_set_boxed (value, &geom);
+                  g_value_set_boxed (value, &rect);
                   return TRUE;
                 }
             }
@@ -1441,9 +1442,9 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_POINT))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_POINT))
             {
-              ClutterPoint point = CLUTTER_POINT_INIT_ZERO;
+              graphene_point_t point = GRAPHENE_POINT_INIT_ZERO;
 
               if (_clutter_script_parse_point (script, node, &point))
                 {
@@ -1451,9 +1452,9 @@ _clutter_script_parse_node (ClutterScript *script,
                   return TRUE;
                 }
             }
-          else if (G_VALUE_HOLDS (value, CLUTTER_TYPE_SIZE))
+          else if (G_VALUE_HOLDS (value, GRAPHENE_TYPE_SIZE))
             {
-              ClutterSize size = CLUTTER_SIZE_INIT_ZERO;
+              graphene_size_t size = GRAPHENE_SIZE_INIT_ZERO;
 
               if (_clutter_script_parse_size (script, node, &size))
                 {

clutter/clutter/clutter-script-private.h

@@ -122,9 +122,9 @@ gboolean _clutter_script_flags_from_string (GType          gtype,
 gboolean _clutter_script_parse_knot        (ClutterScript   *script,
                                             JsonNode        *node,
                                             ClutterKnot     *knot);
-gboolean _clutter_script_parse_geometry    (ClutterScript   *script,
+gboolean _clutter_script_parse_rect        (ClutterScript   *script,
                                             JsonNode        *node,
-                                            ClutterGeometry *geometry);
+                                            graphene_rect_t *rect);
 gboolean _clutter_script_parse_color       (ClutterScript   *script,
                                             JsonNode        *node,
                                             ClutterColor    *color);
@@ -132,10 +132,10 @@ GObject *_clutter_script_parse_alpha       (ClutterScript   *script,
                                             JsonNode        *node);
 gboolean _clutter_script_parse_point       (ClutterScript   *script,
                                             JsonNode        *node,
-                                            ClutterPoint    *point);
+                                            graphene_point_t *point);
 gboolean _clutter_script_parse_size        (ClutterScript   *script,
                                             JsonNode        *node,
-                                            ClutterSize     *size);
+                                            graphene_size_t *size);
 
 gboolean _clutter_script_parse_translatable_string (ClutterScript *script,
                                                     JsonNode      *node,

clutter/clutter/clutter-scroll-actor.c

@@ -56,7 +56,7 @@
 
 struct _ClutterScrollActorPrivate
 {
-  ClutterPoint scroll_to;
+  graphene_point_t scroll_to;
 
   ClutterScrollMode scroll_mode;
 
@@ -94,19 +94,19 @@ G_DEFINE_TYPE_WITH_CODE (ClutterScrollActor, clutter_scroll_actor, CLUTTER_TYPE_
                                                 clutter_animatable_iface_init))
 
 static void
-clutter_scroll_actor_set_scroll_to_internal (ClutterScrollActor *self,
-                                             const ClutterPoint *point)
+clutter_scroll_actor_set_scroll_to_internal (ClutterScrollActor     *self,
+                                             const graphene_point_t *point)
 {
   ClutterScrollActorPrivate *priv = self->priv;
   ClutterActor *actor = CLUTTER_ACTOR (self);
   ClutterMatrix m = CLUTTER_MATRIX_INIT_IDENTITY;
   float dx, dy;
 
-  if (clutter_point_equals (&priv->scroll_to, point))
+  if (graphene_point_equal (&priv->scroll_to, point))
     return;
 
   if (point == NULL)
-    clutter_point_init (&priv->scroll_to, 0.f, 0.f);
+    graphene_point_init (&priv->scroll_to, 0.f, 0.f);
   else
     priv->scroll_to = *point;
 
@@ -216,7 +216,7 @@ clutter_scroll_actor_set_final_state (ClutterAnimatable *animatable,
   if (strcmp (property_name, "scroll-to") == 0)
     {
       ClutterScrollActor *self = CLUTTER_SCROLL_ACTOR (animatable);
-      const ClutterPoint *point = g_value_get_boxed (value);
+      const graphene_point_t *point = g_value_get_boxed (value);
 
       clutter_scroll_actor_set_scroll_to_internal (self, point);
     }
@@ -248,7 +248,7 @@ clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
     g_param_spec_boxed ("scroll-to",
                         "Scroll To",
                         "The point to scroll the actor to",
-                        CLUTTER_TYPE_POINT,
+                        GRAPHENE_TYPE_POINT,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_STRINGS |
                         CLUTTER_PARAM_ANIMATABLE);
@@ -322,7 +322,7 @@ clutter_scroll_actor_get_scroll_mode (ClutterScrollActor *actor)
 /**
  * clutter_scroll_actor_scroll_to_point:
  * @actor: a #ClutterScrollActor
- * @point: a #ClutterPoint
+ * @point: a #graphene_point_t
  *
  * Scrolls the contents of @actor so that @point is the new origin
  * of the visible area.
@@ -335,8 +335,8 @@ clutter_scroll_actor_get_scroll_mode (ClutterScrollActor *actor)
  * Since: 1.12
  */
 void
-clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,
-                                      const ClutterPoint *point)
+clutter_scroll_actor_scroll_to_point (ClutterScrollActor     *actor,
+                                      const graphene_point_t *point)
 {
   ClutterScrollActorPrivate *priv;
   const ClutterAnimationInfo *info;
@@ -390,10 +390,10 @@ clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,
 
   /* if a transition already exist, update its bounds */
   clutter_transition_set_from (priv->transition,
-                               CLUTTER_TYPE_POINT,
+                               GRAPHENE_TYPE_POINT,
                                &priv->scroll_to);
   clutter_transition_set_to (priv->transition,
-                             CLUTTER_TYPE_POINT,
+                             GRAPHENE_TYPE_POINT,
                              point);
 
   /* always use the current easing state */
@@ -417,10 +417,10 @@ clutter_scroll_actor_scroll_to_point (ClutterScrollActor *actor,
  * Since: 1.12
  */
 void
-clutter_scroll_actor_scroll_to_rect (ClutterScrollActor *actor,
-                                     const ClutterRect  *rect)
+clutter_scroll_actor_scroll_to_rect (ClutterScrollActor    *actor,
+                                     const graphene_rect_t *rect)
 {
-  ClutterRect n_rect;
+  graphene_rect_t n_rect;
 
   g_return_if_fail (CLUTTER_IS_SCROLL_ACTOR (actor));
   g_return_if_fail (rect != NULL);
@@ -428,7 +428,7 @@ clutter_scroll_actor_scroll_to_rect (ClutterScrollActor *actor,
   n_rect = *rect;
 
   /* normalize, so that we have a valid origin */
-  clutter_rect_normalize (&n_rect);
+  graphene_rect_normalize (&n_rect);
 
   clutter_scroll_actor_scroll_to_point (actor, &n_rect.origin);
 }

clutter/clutter/clutter-scroll-actor.h

@@ -86,11 +86,11 @@ CLUTTER_EXPORT
 ClutterScrollMode       clutter_scroll_actor_get_scroll_mode    (ClutterScrollActor *actor);
 
 CLUTTER_EXPORT
-void                    clutter_scroll_actor_scroll_to_point    (ClutterScrollActor *actor,
-                                                                 const ClutterPoint *point);
+void                    clutter_scroll_actor_scroll_to_point    (ClutterScrollActor     *actor,
+                                                                 const graphene_point_t *point);
 CLUTTER_EXPORT
-void                    clutter_scroll_actor_scroll_to_rect     (ClutterScrollActor *actor,
-                                                                 const ClutterRect  *rect);
+void                    clutter_scroll_actor_scroll_to_rect     (ClutterScrollActor    *actor,
+                                                                 const graphene_rect_t *rect);
 
 G_END_DECLS
 

clutter/clutter/clutter-stage-private.h

@@ -124,9 +124,9 @@ gboolean                _clutter_stage_update_state     (ClutterStage      *stag
 
 void                    _clutter_stage_set_scale_factor (ClutterStage      *stage,
                                                          int                factor);
-gboolean                _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage *stage,
-                                                                           ClutterRect  *rect,
-                                                                           float        *view_scale);
+gboolean                _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
+                                                                           graphene_rect_t *rect,
+                                                                           float           *view_scale);
 
 void            _clutter_stage_presented                (ClutterStage      *stage,
                                                          CoglFrameEvent     frame_event,

clutter/clutter/clutter-stage-view.c

@@ -133,8 +133,8 @@ clutter_stage_view_blit_offscreen (ClutterStageView            *view,
    * the bottom right corner.
    */
   cogl_matrix_init_identity (&matrix);
-  cogl_matrix_translate (&matrix, -1, 1, 0);
   cogl_matrix_scale (&matrix, 2, -2, 0);
+  cogl_matrix_translate (&matrix, -1, 1, 0);
   cogl_framebuffer_set_projection_matrix (priv->framebuffer, &matrix);
 
   cogl_framebuffer_draw_rectangle (priv->framebuffer,

clutter/clutter/clutter-stage.c

@@ -114,8 +114,6 @@ struct _ClutterStagePrivate
   CoglMatrix view;
   float viewport[4];
 
-  ClutterFog fog;
-
   gchar *title;
   ClutterActor *key_focused_actor;
 
@@ -154,7 +152,6 @@ struct _ClutterStagePrivate
   guint is_fullscreen          : 1;
   guint is_cursor_visible      : 1;
   guint is_user_resizable      : 1;
-  guint use_fog                : 1;
   guint throttle_motion_events : 1;
   guint use_alpha              : 1;
   guint min_size_changed       : 1;
@@ -175,8 +172,6 @@ enum
   PROP_PERSPECTIVE,
   PROP_TITLE,
   PROP_USER_RESIZABLE,
-  PROP_USE_FOG,
-  PROP_FOG,
   PROP_USE_ALPHA,
   PROP_KEY_FOCUS,
   PROP_NO_CLEAR_HINT,
@@ -514,8 +509,9 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
   Vector4 *tmp_poly;
   ClutterPlane *plane;
   int i;
-  float b[3];
-  float c[3];
+  Vector4 *poly;
+  graphene_vec3_t b;
+  graphene_vec3_t c;
   int count;
 
   tmp_poly = g_alloca (sizeof (Vector4) * n_vertices * 2);
@@ -536,7 +532,7 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
    * frustum; coordinates range from [-Wc,Wc] left to right on the
    * x-axis and [Wc,-Wc] top to bottom on the y-axis.
    */
-  Wc = DEPTH * projection->wz + projection->ww;
+  Wc = DEPTH * projection->zw + projection->ww;
 
 #define CLIP_X(X) ((((float)X - viewport[0]) * (2.0 / viewport[2])) - 1) * Wc
 #define CLIP_Y(Y) ((((float)Y - viewport[1]) * (2.0 / viewport[3])) - 1) * -Wc
@@ -549,7 +545,7 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
       tmp_poly[i].w = Wc;
     }
 
-  Wc = DEPTH * 2 * projection->wz + projection->ww;
+  Wc = DEPTH * 2 * projection->zw + projection->ww;
 
   /* FIXME: technically we don't need to project all of the points
    * twice, it would be enough project every other point since
@@ -582,23 +578,37 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
   for (i = 0; i < count; i++)
     {
       plane = &planes[i];
-      memcpy (plane->v0, tmp_poly + i, sizeof (float) * 3);
-      memcpy (b, tmp_poly + n_vertices + i, sizeof (float) * 3);
-      memcpy (c, tmp_poly + n_vertices + i + 1, sizeof (float) * 3);
-      cogl_vector3_subtract (b, b, plane->v0);
-      cogl_vector3_subtract (c, c, plane->v0);
-      cogl_vector3_cross_product (plane->n, b, c);
-      cogl_vector3_normalize (plane->n);
+
+      poly = &tmp_poly[i];
+      graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
+
+      poly = &tmp_poly[n_vertices + i];
+      graphene_vec3_init (&b, poly->x, poly->y, poly->z);
+
+      poly = &tmp_poly[n_vertices + i + 1];
+      graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+      graphene_vec3_subtract (&b, &plane->v0, &b);
+      graphene_vec3_subtract (&c, &plane->v0, &c);
+      graphene_vec3_cross (&b, &c, &plane->n);
+      graphene_vec3_normalize (&plane->n, &plane->n);
     }
 
   plane = &planes[n_vertices - 1];
-  memcpy (plane->v0, tmp_poly + 0, sizeof (float) * 3);
-  memcpy (b, tmp_poly + (2 * n_vertices - 1), sizeof (float) * 3);
-  memcpy (c, tmp_poly + n_vertices, sizeof (float) * 3);
-  cogl_vector3_subtract (b, b, plane->v0);
-  cogl_vector3_subtract (c, c, plane->v0);
-  cogl_vector3_cross_product (plane->n, b, c);
-  cogl_vector3_normalize (plane->n);
+
+  poly = &tmp_poly[0];
+  graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
+
+  poly = &tmp_poly[2 * n_vertices - 1];
+  graphene_vec3_init (&b, poly->x, poly->y, poly->z);
+
+  poly = &tmp_poly[n_vertices];
+  graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+  graphene_vec3_subtract (&b, &plane->v0, &b);
+  graphene_vec3_subtract (&c, &plane->v0, &c);
+  graphene_vec3_cross (&b, &c, &plane->n);
+  graphene_vec3_normalize (&plane->n, &plane->n);
 }
 
 static void
@@ -1154,7 +1164,7 @@ _clutter_stage_check_updated_pointers (ClutterStage *stage)
   GSList *updating = NULL;
   const GSList *devices;
   cairo_rectangle_int_t clip;
-  ClutterPoint point;
+  graphene_point_t point;
   gboolean has_clip;
 
   has_clip = _clutter_stage_window_get_redraw_clip_bounds (priv->impl, &clip);
@@ -1727,14 +1737,6 @@ clutter_stage_set_property (GObject      *object,
       clutter_stage_set_user_resizable (stage, g_value_get_boolean (value));
       break;
 
-    case PROP_USE_FOG:
-      clutter_stage_set_use_fog (stage, g_value_get_boolean (value));
-      break;
-
-    case PROP_FOG:
-      clutter_stage_set_fog (stage, g_value_get_boxed (value));
-      break;
-
     case PROP_USE_ALPHA:
       clutter_stage_set_use_alpha (stage, g_value_get_boolean (value));
       break;
@@ -1801,14 +1803,6 @@ clutter_stage_get_property (GObject    *gobject,
       g_value_set_boolean (value, priv->is_user_resizable);
       break;
 
-    case PROP_USE_FOG:
-      g_value_set_boolean (value, priv->use_fog);
-      break;
-
-    case PROP_FOG:
-      g_value_set_boxed (value, &priv->fog);
-      break;
-
     case PROP_USE_ALPHA:
       g_value_set_boolean (value, priv->use_alpha);
       break;
@@ -2035,41 +2029,6 @@ clutter_stage_class_init (ClutterStageClass *klass)
                                CLUTTER_PARAM_READWRITE);
   g_object_class_install_property (gobject_class, PROP_TITLE, pspec);
 
-  /**
-   * ClutterStage:use-fog:
-   *
-   * Whether the stage should use a linear GL "fog" in creating the
-   * depth-cueing effect, to enhance the perception of depth by fading
-   * actors farther from the viewpoint.
-   *
-   * Since: 0.6
-   *
-   * Deprecated: 1.10: This property does not do anything.
-   */
-  pspec = g_param_spec_boolean ("use-fog",
-                                P_("Use Fog"),
-                                P_("Whether to enable depth cueing"),
-                                FALSE,
-                                CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_USE_FOG, pspec);
-
-  /**
-   * ClutterStage:fog:
-   *
-   * The settings for the GL "fog", used only if #ClutterStage:use-fog
-   * is set to %TRUE
-   *
-   * Since: 1.0
-   *
-   * Deprecated: 1.10: This property does not do anything.
-   */
-  pspec = g_param_spec_boxed ("fog",
-                              P_("Fog"),
-                              P_("Settings for the depth cueing"),
-                              CLUTTER_TYPE_FOG,
-                              CLUTTER_PARAM_READWRITE | G_PARAM_DEPRECATED);
-  g_object_class_install_property (gobject_class, PROP_FOG, pspec);
-
   /**
    * ClutterStage:use-alpha:
    *
@@ -2322,7 +2281,6 @@ clutter_stage_init (ClutterStage *self)
   priv->is_fullscreen = FALSE;
   priv->is_user_resizable = FALSE;
   priv->is_cursor_visible = TRUE;
-  priv->use_fog = FALSE;
   priv->throttle_motion_events = TRUE;
   priv->min_size_changed = FALSE;
   priv->sync_delay = -1;
@@ -2360,11 +2318,6 @@ clutter_stage_init (ClutterStage *self)
                                       geom.width,
                                       geom.height);
 
-
-  /* FIXME - remove for 2.0 */
-  priv->fog.z_near = 1.0;
-  priv->fog.z_far  = 2.0;
-
   priv->relayout_pending = TRUE;
 
   clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
@@ -3257,136 +3210,6 @@ clutter_stage_get_key_focus (ClutterStage *stage)
   return CLUTTER_ACTOR (stage);
 }
 
-/**
- * clutter_stage_get_use_fog:
- * @stage: the #ClutterStage
- *
- * Gets whether the depth cueing effect is enabled on @stage.
- *
- * Return value: %TRUE if the depth cueing effect is enabled
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: This function will always return %FALSE
- */
-gboolean
-clutter_stage_get_use_fog (ClutterStage *stage)
-{
-  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
-
-  return stage->priv->use_fog;
-}
-
-/**
- * clutter_stage_set_use_fog:
- * @stage: the #ClutterStage
- * @fog: %TRUE for enabling the depth cueing effect
- *
- * Sets whether the depth cueing effect on the stage should be enabled
- * or not.
- *
- * Depth cueing is a 3D effect that makes actors farther away from the
- * viewing point less opaque, by fading them with the stage color.
-
- * The parameters of the GL fog used can be changed using the
- * clutter_stage_set_fog() function.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: Calling this function produces no visible effect
- */
-void
-clutter_stage_set_use_fog (ClutterStage *stage,
-                           gboolean      fog)
-{
-}
-
-/**
- * clutter_stage_set_fog:
- * @stage: the #ClutterStage
- * @fog: a #ClutterFog structure
- *
- * Sets the fog (also known as "depth cueing") settings for the @stage.
- *
- * A #ClutterStage will only use a linear fog progression, which
- * depends solely on the distance from the viewer. The cogl_set_fog()
- * function in COGL exposes more of the underlying implementation,
- * and allows changing the for progression function. It can be directly
- * used by disabling the #ClutterStage:use-fog property and connecting
- * a signal handler to the #ClutterActor::paint signal on the @stage,
- * like:
- *
- * |[
- *   clutter_stage_set_use_fog (stage, FALSE);
- *   g_signal_connect (stage, "paint", G_CALLBACK (on_stage_paint), NULL);
- * ]|
- *
- * The paint signal handler will call cogl_set_fog() with the
- * desired settings:
- *
- * |[
- *   static void
- *   on_stage_paint (ClutterActor *actor)
- *   {
- *     ClutterColor stage_color = { 0, };
- *     CoglColor fog_color = { 0, };
- *
- *     // set the fog color to the stage background color
- *     clutter_stage_get_color (CLUTTER_STAGE (actor), &stage_color);
- *     cogl_color_init_from_4ub (&fog_color,
- *                               stage_color.red,
- *                               stage_color.green,
- *                               stage_color.blue,
- *                               stage_color.alpha);
- *
- *     // enable fog //
- *     cogl_set_fog (&fog_color,
- *                   COGL_FOG_MODE_EXPONENTIAL, // mode
- *                   0.5,                       // density
- *                   5.0, 30.0);                // z_near and z_far
- *   }
- * ]|
- *
- * The fogging functions only work correctly when the visible actors use
- * unmultiplied alpha colors. By default Cogl will premultiply textures and
- * cogl_set_source_color() will premultiply colors, so unless you explicitly
- * load your textures requesting an unmultiplied internal format and use
- * cogl_material_set_color() you can only use fogging with fully opaque actors.
- * Support for premultiplied colors will improve in the future when we can
- * depend on fragment shaders.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: Fog settings are ignored.
- */
-void
-clutter_stage_set_fog (ClutterStage *stage,
-                       ClutterFog   *fog)
-{
-}
-
-/**
- * clutter_stage_get_fog:
- * @stage: the #ClutterStage
- * @fog: (out): return location for a #ClutterFog structure
- *
- * Retrieves the current depth cueing settings from the stage.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: This function will always return the default
- *   values of #ClutterFog
- */
-void
-clutter_stage_get_fog (ClutterStage *stage,
-                        ClutterFog   *fog)
-{
-  g_return_if_fail (CLUTTER_IS_STAGE (stage));
-  g_return_if_fail (fog != NULL);
-
-  *fog = stage->priv->fog;
-}
-
 /*** Perspective boxed type ******/
 
 static gpointer
@@ -3409,24 +3232,6 @@ G_DEFINE_BOXED_TYPE (ClutterPerspective, clutter_perspective,
                      clutter_perspective_copy,
                      clutter_perspective_free);
 
-static gpointer
-clutter_fog_copy (gpointer data)
-{
-  if (G_LIKELY (data))
-    return g_slice_dup (ClutterFog, data);
-
-  return NULL;
-}
-
-static void
-clutter_fog_free (gpointer data)
-{
-  if (G_LIKELY (data))
-    g_slice_free (ClutterFog, data);
-}
-
-G_DEFINE_BOXED_TYPE (ClutterFog, clutter_fog, clutter_fog_copy, clutter_fog_free);
-
 /**
  * clutter_stage_new:
  *
@@ -4863,7 +4668,7 @@ clutter_stage_get_capture_final_size (ClutterStage          *stage,
 
   if (rect)
     {
-      ClutterRect capture_rect;
+      graphene_rect_t capture_rect;
 
       _clutter_util_rect_from_rectangle (rect, &capture_rect);
       if (!_clutter_stage_get_max_view_scale_factor_for_rect (stage,
@@ -5070,9 +4875,9 @@ clutter_stage_update_resource_scales (ClutterStage *stage)
 }
 
 gboolean
-_clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage *stage,
-                                                   ClutterRect  *rect,
-                                                   float        *view_scale)
+_clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage    *stage,
+                                                   graphene_rect_t *rect,
+                                                   float           *view_scale)
 {
   ClutterStagePrivate *priv = stage->priv;
   float scale = 0.0f;
@@ -5082,12 +4887,12 @@ _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage *stage,
     {
       ClutterStageView *view = l->data;
       cairo_rectangle_int_t view_layout;
-      ClutterRect view_rect;
+      graphene_rect_t view_rect;
 
       clutter_stage_view_get_layout (view, &view_layout);
       _clutter_util_rect_from_rectangle (&view_layout, &view_rect);
 
-      if (clutter_rect_intersection (&view_rect, rect, NULL))
+      if (graphene_rect_intersection (&view_rect, rect, NULL))
         scale = MAX (clutter_stage_view_get_scale (view), scale);
     }
 

clutter/clutter/clutter-stage.h

@@ -115,26 +115,6 @@ struct _ClutterPerspective
   gfloat z_far;
 };
 
-/**
- * ClutterFog:
- * @z_near: starting distance from the viewer to the near clipping
- *   plane (always positive)
- * @z_far: final distance from the viewer to the far clipping
- *   plane (always positive)
- *
- * Fog settings used to create the depth cueing effect.
- *
- * Since: 0.6
- *
- * Deprecated: 1.10: The fog-related API in #ClutterStage has been
- *   deprecated as well.
- */
-struct _ClutterFog
-{
-  gfloat z_near;
-  gfloat z_far;
-};
-
 /**
  * ClutterFrameInfo: (skip)
  */
@@ -153,8 +133,6 @@ typedef struct _ClutterCapture
 
 CLUTTER_EXPORT
 GType clutter_perspective_get_type (void) G_GNUC_CONST;
-CLUTTER_DEPRECATED
-GType clutter_fog_get_type (void) G_GNUC_CONST;
 CLUTTER_EXPORT
 GType clutter_stage_get_type (void) G_GNUC_CONST;
 

clutter/clutter/clutter-test-utils.c

@@ -273,7 +273,7 @@ clutter_test_run (void)
 typedef struct {
   ClutterActor *stage;
 
-  ClutterPoint point;
+  graphene_point_t point;
 
   gpointer result;
 
@@ -348,10 +348,10 @@ on_key_press_event (ClutterActor *stage,
  * Since: 1.18
  */
 gboolean
-clutter_test_check_actor_at_point (ClutterActor        *stage,
-                                   const ClutterPoint  *point,
-                                   ClutterActor        *actor,
-                                   ClutterActor       **result)
+clutter_test_check_actor_at_point (ClutterActor            *stage,
+                                   const graphene_point_t  *point,
+                                   ClutterActor            *actor,
+                                   ClutterActor           **result)
 {
   ValidateData *data;
   guint press_id = 0;
@@ -410,10 +410,10 @@ clutter_test_check_actor_at_point (ClutterActor        *stage,
  * Since: 1.18
  */
 gboolean
-clutter_test_check_color_at_point (ClutterActor       *stage,
-                                   const ClutterPoint *point,
-                                   const ClutterColor *color,
-                                   ClutterColor       *result)
+clutter_test_check_color_at_point (ClutterActor           *stage,
+                                   const graphene_point_t *point,
+                                   const ClutterColor     *color,
+                                   ClutterColor           *result)
 {
   ValidateData *data;
   gboolean retval;

clutter/clutter/clutter-test-utils.h

@@ -112,7 +112,7 @@ ClutterActor *  clutter_test_get_stage          (void);
 
 #define clutter_test_assert_actor_at_point(stage,point,actor) \
 G_STMT_START { \
-  const ClutterPoint *__p = (point); \
+  const graphene_point_t *__p = (point); \
   ClutterActor *__actor = (actor); \
   ClutterActor *__stage = (stage); \
   ClutterActor *__res; \
@@ -132,7 +132,7 @@ G_STMT_START { \
 
 #define clutter_test_assert_color_at_point(stage,point,color) \
 G_STMT_START { \
-  const ClutterPoint *__p = (point); \
+  const graphene_point_t *__p = (point); \
   const ClutterColor *__c = (color); \
   ClutterActor *__stage = (stage); \
   ClutterColor __res; \
@@ -149,15 +149,15 @@ G_STMT_START { \
 } G_STMT_END
 
 CLUTTER_EXPORT
-gboolean        clutter_test_check_actor_at_point       (ClutterActor       *stage,
-                                                         const ClutterPoint *point,
-                                                         ClutterActor       *actor,
-                                                         ClutterActor      **result);
+gboolean        clutter_test_check_actor_at_point       (ClutterActor            *stage,
+                                                         const graphene_point_t  *point,
+                                                         ClutterActor            *actor,
+                                                         ClutterActor           **result);
 CLUTTER_EXPORT
-gboolean        clutter_test_check_color_at_point       (ClutterActor       *stage,
-                                                         const ClutterPoint *point,
-                                                         const ClutterColor *color,
-                                                         ClutterColor       *result);
+gboolean        clutter_test_check_color_at_point       (ClutterActor           *stage,
+                                                         const graphene_point_t *point,
+                                                         const ClutterColor     *color,
+                                                         ClutterColor           *result);
 
 G_END_DECLS
 

clutter/clutter/clutter-text.c

@@ -157,7 +157,7 @@ struct _ClutterTextPrivate
   gint text_logical_y;
 
   /* Where to draw the cursor */
-  ClutterRect cursor_rect;
+  graphene_rect_t cursor_rect;
   ClutterColor cursor_color;
   guint cursor_size;
 
@@ -1304,7 +1304,7 @@ static inline void
 update_cursor_location (ClutterText *self)
 {
   ClutterTextPrivate *priv = self->priv;
-  ClutterRect rect;
+  graphene_rect_t rect;
   float x, y;
 
   if (!priv->editable)
@@ -1312,7 +1312,7 @@ update_cursor_location (ClutterText *self)
 
   rect = priv->cursor_rect;
   clutter_actor_get_transformed_position (CLUTTER_ACTOR (self), &x, &y);
-  clutter_rect_offset (&rect, x, y);
+  graphene_rect_offset (&rect, x, y);
   clutter_input_focus_set_cursor_location (priv->input_focus, &rect);
 }
 
@@ -1322,7 +1322,7 @@ clutter_text_ensure_cursor_position (ClutterText *self,
 {
   ClutterTextPrivate *priv = self->priv;
   gfloat x, y, cursor_height;
-  ClutterRect cursor_rect = CLUTTER_RECT_INIT_ZERO;
+  graphene_rect_t cursor_rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);
   gint position;
 
   position = priv->position;
@@ -1345,25 +1345,17 @@ clutter_text_ensure_cursor_position (ClutterText *self,
                                             &x, &y,
                                             &cursor_height);
 
-  clutter_rect_init (&cursor_rect,
-                     x,
-                     y + CURSOR_Y_PADDING * scale,
-                     priv->cursor_size * scale,
-                     cursor_height - 2 * CURSOR_Y_PADDING * scale);
+  graphene_rect_init (&cursor_rect,
+                      x,
+                      y + CURSOR_Y_PADDING * scale,
+                      priv->cursor_size * scale,
+                      cursor_height - 2 * CURSOR_Y_PADDING * scale);
 
-  if (!clutter_rect_equals (&priv->cursor_rect, &cursor_rect))
+  if (!graphene_rect_equal (&priv->cursor_rect, &cursor_rect))
     {
-      ClutterGeometry cursor_pos;
-
       priv->cursor_rect = cursor_rect;
 
-      /* XXX:2.0 - remove */
-      cursor_pos.x = clutter_rect_get_x (&priv->cursor_rect);
-      cursor_pos.y = clutter_rect_get_y (&priv->cursor_rect);
-      cursor_pos.width = clutter_rect_get_width (&priv->cursor_rect);
-      cursor_pos.height = clutter_rect_get_height (&priv->cursor_rect);
-      g_signal_emit (self, text_signals[CURSOR_EVENT], 0, &cursor_pos);
-
+      g_signal_emit (self, text_signals[CURSOR_EVENT], 0, &cursor_rect);
       g_signal_emit (self, text_signals[CURSOR_CHANGED], 0);
 
       update_cursor_location (self);
@@ -2700,7 +2692,7 @@ clutter_text_paint (ClutterActor *self)
 
       if (actor_width < text_width)
         {
-          gint cursor_x = clutter_rect_get_x (&priv->cursor_rect);
+          gint cursor_x = graphene_rect_get_x (&priv->cursor_rect);
 
           if (priv->position == -1)
             {
@@ -2787,7 +2779,7 @@ add_selection_to_paint_volume (ClutterText           *text,
 {
   ClutterPaintVolume *total_volume = user_data;
   ClutterPaintVolume rect_volume;
-  ClutterVertex vertex;
+  graphene_point3d_t vertex;
 
   _clutter_paint_volume_init_static (&rect_volume, CLUTTER_ACTOR (text));
 
@@ -2809,7 +2801,7 @@ clutter_text_get_paint_volume_for_cursor (ClutterText        *text,
                                           ClutterPaintVolume *volume)
 {
   ClutterTextPrivate *priv = text->priv;
-  ClutterVertex origin;
+  graphene_point3d_t origin;
 
   clutter_text_ensure_cursor_position (text, resource_scale);
 
@@ -2852,7 +2844,7 @@ clutter_text_get_paint_volume (ClutterActor       *self,
     {
       PangoLayout *layout;
       PangoRectangle ink_rect;
-      ClutterVertex origin;
+      graphene_point3d_t origin;
       float resource_scale;
 
       /* If the text is single line editable then it gets clipped to
@@ -4388,10 +4380,10 @@ clutter_text_class_init (ClutterTextClass *klass)
   /**
    * ClutterText::cursor-event:
    * @self: the #ClutterText that emitted the signal
-   * @geometry: the coordinates of the cursor
+   * @rect: the coordinates of the cursor
    *
    * The ::cursor-event signal is emitted whenever the cursor position
-   * changes inside a #ClutterText actor. Inside @geometry it is stored
+   * changes inside a #ClutterText actor. Inside @rect it is stored
    * the current position and size of the cursor, relative to the actor
    * itself.
    *
@@ -4407,7 +4399,7 @@ clutter_text_class_init (ClutterTextClass *klass)
 		  NULL, NULL,
 		  _clutter_marshal_VOID__BOXED,
 		  G_TYPE_NONE, 1,
-		  CLUTTER_TYPE_GEOMETRY | G_SIGNAL_TYPE_STATIC_SCOPE);
+		  GRAPHENE_TYPE_RECT | G_SIGNAL_TYPE_STATIC_SCOPE);
 
   /**
    * ClutterText::cursor-changed:
@@ -6772,8 +6764,8 @@ clutter_text_get_layout_offsets (ClutterText *self,
  * Since: 1.16
  */
 void
-clutter_text_get_cursor_rect (ClutterText *self,
-                              ClutterRect *rect)
+clutter_text_get_cursor_rect (ClutterText     *self,
+                              graphene_rect_t *rect)
 {
   g_return_if_fail (CLUTTER_IS_TEXT (self));
   g_return_if_fail (rect != NULL);

clutter/clutter/clutter-text.h

@@ -82,7 +82,7 @@ struct _ClutterTextClass
   void (* text_changed)   (ClutterText           *self);
   void (* activate)       (ClutterText           *self);
   void (* cursor_event)   (ClutterText           *self,
-                           const ClutterGeometry *geometry);
+                           const graphene_rect_t *rect);
   void (* cursor_changed) (ClutterText           *self);
 
   /*< private >*/
@@ -230,7 +230,7 @@ CLUTTER_EXPORT
 guint                 clutter_text_get_cursor_size      (ClutterText          *self);
 CLUTTER_EXPORT
 void                  clutter_text_get_cursor_rect      (ClutterText          *self,
-                                                         ClutterRect          *rect);
+                                                         graphene_rect_t      *rect);
 CLUTTER_EXPORT
 void                  clutter_text_set_selectable       (ClutterText          *self,
                                                          gboolean              selectable);

clutter/clutter/clutter-timeline.c

@@ -145,8 +145,8 @@ struct _ClutterTimelinePrivate
   ClutterStepMode step_mode;
 
   /* cubic-bezier() parameters */
-  ClutterPoint cb_1;
-  ClutterPoint cb_2;
+  graphene_point_t cb_1;
+  graphene_point_t cb_2;
 
   guint is_playing         : 1;
 
@@ -850,8 +850,8 @@ clutter_timeline_init (ClutterTimeline *self)
   self->priv->step_mode = CLUTTER_STEP_MODE_END;
 
   /* default cubic-bezier() paramereters are (0, 0, 1, 1) */
-  clutter_point_init (&self->priv->cb_1, 0, 0);
-  clutter_point_init (&self->priv->cb_2, 1, 1);
+  graphene_point_init (&self->priv->cb_1, 0, 0);
+  graphene_point_init (&self->priv->cb_2, 1, 1);
 }
 
 struct CheckIfMarkerHitClosure
@@ -2493,9 +2493,9 @@ clutter_timeline_get_step_progress (ClutterTimeline *timeline,
  * Since: 1.12
  */
 void
-clutter_timeline_set_cubic_bezier_progress (ClutterTimeline    *timeline,
-                                            const ClutterPoint *c_1,
-                                            const ClutterPoint *c_2)
+clutter_timeline_set_cubic_bezier_progress (ClutterTimeline        *timeline,
+                                            const graphene_point_t *c_1,
+                                            const graphene_point_t *c_2)
 {
   ClutterTimelinePrivate *priv;
 
@@ -2530,9 +2530,9 @@ clutter_timeline_set_cubic_bezier_progress (ClutterTimeline    *timeline,
  * Since: 1.12
  */
 gboolean
-clutter_timeline_get_cubic_bezier_progress (ClutterTimeline *timeline,
-                                            ClutterPoint    *c_1,
-                                            ClutterPoint    *c_2)
+clutter_timeline_get_cubic_bezier_progress (ClutterTimeline  *timeline,
+                                            graphene_point_t *c_1,
+                                            graphene_point_t *c_2)
 {
   g_return_val_if_fail (CLUTTER_IS_TIMELINE (timeline), FALSE);
 

clutter/clutter/clutter-timeline.h

@@ -209,12 +209,12 @@ gboolean                        clutter_timeline_get_step_progress
                                                                                  ClutterStepMode          *step_mode);
 CLUTTER_EXPORT
 void                            clutter_timeline_set_cubic_bezier_progress      (ClutterTimeline          *timeline,
-                                                                                 const ClutterPoint       *c_1,
-                                                                                 const ClutterPoint       *c_2);
+                                                                                 const graphene_point_t   *c_1,
+                                                                                 const graphene_point_t   *c_2);
 CLUTTER_EXPORT
 gboolean                        clutter_timeline_get_cubic_bezier_progress      (ClutterTimeline          *timeline,
-                                                                                 ClutterPoint             *c_1,
-                                                                                 ClutterPoint             *c_2);
+                                                                                 graphene_point_t         *c_1,
+                                                                                 graphene_point_t         *c_2);
 
 CLUTTER_EXPORT
 gint64                          clutter_timeline_get_duration_hint              (ClutterTimeline          *timeline);

clutter/clutter/clutter-types.h

@@ -33,20 +33,16 @@
 #include <clutter/clutter-macros.h>
 #include <clutter/clutter-enums.h>
 
+#include <graphene-gobject.h>
+
 G_BEGIN_DECLS
 
 #define CLUTTER_TYPE_ACTOR_BOX          (clutter_actor_box_get_type ())
-#define CLUTTER_TYPE_FOG                (clutter_fog_get_type ())
-#define CLUTTER_TYPE_GEOMETRY           (clutter_geometry_get_type ())
 #define CLUTTER_TYPE_KNOT               (clutter_knot_get_type ())
 #define CLUTTER_TYPE_MARGIN             (clutter_margin_get_type ())
 #define CLUTTER_TYPE_MATRIX             (clutter_matrix_get_type ())
 #define CLUTTER_TYPE_PAINT_VOLUME       (clutter_paint_volume_get_type ())
 #define CLUTTER_TYPE_PERSPECTIVE        (clutter_perspective_get_type ())
-#define CLUTTER_TYPE_VERTEX             (clutter_vertex_get_type ())
-#define CLUTTER_TYPE_POINT              (clutter_point_get_type ())
-#define CLUTTER_TYPE_SIZE               (clutter_size_get_type ())
-#define CLUTTER_TYPE_RECT               (clutter_rect_get_type ())
 
 typedef struct _ClutterActor                    ClutterActor;
 
@@ -79,14 +75,9 @@ typedef struct _ClutterPathNode                 ClutterPathNode;
 
 typedef struct _ClutterActorBox                 ClutterActorBox;
 typedef struct _ClutterColor                    ClutterColor;
-typedef struct _ClutterGeometry                 ClutterGeometry; /* XXX:2.0 - remove */
 typedef struct _ClutterKnot                     ClutterKnot;
 typedef struct _ClutterMargin                   ClutterMargin;
 typedef struct _ClutterPerspective              ClutterPerspective;
-typedef struct _ClutterPoint                    ClutterPoint;
-typedef struct _ClutterRect                     ClutterRect;
-typedef struct _ClutterSize                     ClutterSize;
-typedef struct _ClutterVertex                   ClutterVertex;
 
 typedef struct _ClutterAlpha            	ClutterAlpha;
 typedef struct _ClutterAnimation                ClutterAnimation;
@@ -113,7 +104,6 @@ typedef union _ClutterEvent                     ClutterEvent;
  */
 typedef struct _ClutterEventSequence            ClutterEventSequence;
 
-typedef struct _ClutterFog                      ClutterFog; /* deprecated */
 typedef struct _ClutterBehaviour                ClutterBehaviour; /* deprecated */
 typedef struct _ClutterShader                   ClutterShader; /* deprecated */
 
@@ -137,307 +127,6 @@ typedef struct _ClutterShader                   ClutterShader; /* deprecated */
  */
 typedef struct _ClutterPaintVolume      ClutterPaintVolume;
 
-/**
- * ClutterPoint:
- * @x: X coordinate, in pixels
- * @y: Y coordinate, in pixels
- *
- * A point in 2D space.
- *
- * Since: 1.12
- */
-struct _ClutterPoint
-{
-  float x;
-  float y;
-};
-
-/**
- * CLUTTER_POINT_INIT:
- * @x: X coordinate
- * @y: Y coordinate
- *
- * A simple macro for initializing a #ClutterPoint when declaring it, e.g.:
- *
- * |[
- *   ClutterPoint p = CLUTTER_POINT_INIT (100, 100);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_POINT_INIT(x,y)         { (x), (y) }
-
-/**
- * CLUTTER_POINT_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterPoint to (0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_POINT_INIT_ZERO         CLUTTER_POINT_INIT (0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_point_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-const ClutterPoint *    clutter_point_zero      (void);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_alloc     (void);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_init      (ClutterPoint       *point,
-                                                 float               x,
-                                                 float               y);
-CLUTTER_EXPORT
-ClutterPoint *          clutter_point_copy      (const ClutterPoint *point);
-CLUTTER_EXPORT
-void                    clutter_point_free      (ClutterPoint       *point);
-CLUTTER_EXPORT
-gboolean                clutter_point_equals    (const ClutterPoint *a,
-                                                 const ClutterPoint *b);
-CLUTTER_EXPORT
-float                   clutter_point_distance  (const ClutterPoint *a,
-                                                 const ClutterPoint *b,
-                                                 float              *x_distance,
-                                                 float              *y_distance);
-
-/**
- * ClutterSize:
- * @width: the width, in pixels
- * @height: the height, in pixels
- *
- * A size, in 2D space.
- *
- * Since: 1.12
- */
-struct _ClutterSize
-{
-  float width;
-  float height;
-};
-
-/**
- * CLUTTER_SIZE_INIT:
- * @width: the width
- * @height: the height
- *
- * A simple macro for initializing a #ClutterSize when declaring it, e.g.:
- *
- * |[
- *   ClutterSize s = CLUTTER_SIZE_INIT (200, 200);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_SIZE_INIT(width,height) { (width), (height) }
-
-/**
- * CLUTTER_SIZE_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterSize to (0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_SIZE_INIT_ZERO          CLUTTER_SIZE_INIT (0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_size_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_alloc      (void);
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_init       (ClutterSize       *size,
-                                         float              width,
-                                         float              height);
-CLUTTER_EXPORT
-ClutterSize *   clutter_size_copy       (const ClutterSize *size);
-CLUTTER_EXPORT
-void            clutter_size_free       (ClutterSize       *size);
-CLUTTER_EXPORT
-gboolean        clutter_size_equals     (const ClutterSize *a,
-                                         const ClutterSize *b);
-
-/**
- * ClutterRect:
- * @origin: the origin of the rectangle
- * @size: the size of the rectangle
- *
- * The location and size of a rectangle.
- *
- * The width and height of a #ClutterRect can be negative; Clutter considers
- * a rectangle with an origin of [ 0.0, 0.0 ] and a size of [ 10.0, 10.0 ] to
- * be equivalent to a rectangle with origin of [ 10.0, 10.0 ] and size of
- * [ -10.0, -10.0 ].
- *
- * Application code can normalize rectangles using clutter_rect_normalize():
- * this function will ensure that the width and height of a #ClutterRect are
- * positive values. All functions taking a #ClutterRect as an argument will
- * implicitly normalize it before computing eventual results. For this reason
- * it is safer to access the contents of a #ClutterRect by using the provided
- * API at all times, instead of directly accessing the structure members.
- *
- * Since: 1.12
- */
-struct _ClutterRect
-{
-  ClutterPoint origin;
-  ClutterSize size;
-};
-
-/**
- * CLUTTER_RECT_INIT:
- * @x: the X coordinate
- * @y: the Y coordinate
- * @width: the width
- * @height: the height
- *
- * A simple macro for initializing a #ClutterRect when declaring it, e.g.:
- *
- * |[
- *   ClutterRect r = CLUTTER_RECT_INIT (100, 100, 200, 200);
- * ]|
- *
- * Since: 1.12
- */
-#define CLUTTER_RECT_INIT(x,y,width,height)     { { (x), (y) }, { (width), (height) } }
-
-/**
- * CLUTTER_RECT_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterRect to (0, 0, 0, 0) when
- * declaring it.
- *
- * Since: 1.12
- */
-#define CLUTTER_RECT_INIT_ZERO                  CLUTTER_RECT_INIT (0.f, 0.f, 0.f, 0.f)
-
-CLUTTER_EXPORT
-GType clutter_rect_get_type (void) G_GNUC_CONST;
-
-CLUTTER_EXPORT
-const ClutterRect *     clutter_rect_zero               (void);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_alloc              (void);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_init               (ClutterRect       *rect,
-                                                         float              x,
-                                                         float              y,
-                                                         float              width,
-                                                         float              height);
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_copy               (const ClutterRect *rect);
-CLUTTER_EXPORT
-void                    clutter_rect_free               (ClutterRect       *rect);
-CLUTTER_EXPORT
-gboolean                clutter_rect_equals             (ClutterRect       *a,
-                                                         ClutterRect       *b);
-
-CLUTTER_EXPORT
-ClutterRect *           clutter_rect_normalize          (ClutterRect       *rect);
-CLUTTER_EXPORT
-void                    clutter_rect_get_center         (ClutterRect       *rect,
-                                                         ClutterPoint      *center);
-CLUTTER_EXPORT
-gboolean                clutter_rect_contains_point     (ClutterRect       *rect,
-                                                         ClutterPoint      *point);
-CLUTTER_EXPORT
-gboolean                clutter_rect_contains_rect      (ClutterRect       *a,
-                                                         ClutterRect       *b);
-CLUTTER_EXPORT
-void                    clutter_rect_union              (ClutterRect       *a,
-                                                         ClutterRect       *b,
-                                                         ClutterRect       *res);
-CLUTTER_EXPORT
-gboolean                clutter_rect_intersection       (ClutterRect       *a,
-                                                         ClutterRect       *b,
-                                                         ClutterRect       *res);
-CLUTTER_EXPORT
-void                    clutter_rect_offset             (ClutterRect       *rect,
-                                                         float              d_x,
-                                                         float              d_y);
-CLUTTER_EXPORT
-void                    clutter_rect_inset              (ClutterRect       *rect,
-                                                         float              d_x,
-                                                         float              d_y);
-CLUTTER_EXPORT
-void                    clutter_rect_scale              (ClutterRect       *rect,
-                                                         float              s_x,
-                                                         float              s_y);
-CLUTTER_EXPORT
-void                    clutter_rect_clamp_to_pixel     (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_x              (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_y              (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_width          (ClutterRect       *rect);
-CLUTTER_EXPORT
-float                   clutter_rect_get_height         (ClutterRect       *rect);
-
-/**
- * ClutterVertex:
- * @x: X coordinate of the vertex
- * @y: Y coordinate of the vertex
- * @z: Z coordinate of the vertex
- *
- * A point in 3D space, expressed in pixels
- *
- * Since: 0.4
- */
-struct _ClutterVertex
-{
-  gfloat x;
-  gfloat y;
-  gfloat z;
-};
-
-/**
- * CLUTTER_VERTEX_INIT:
- * @x: the X coordinate of the vertex
- * @y: the Y coordinate of the vertex
- * @z: the Z coordinate of the vertex
- *
- * A simple macro for initializing a #ClutterVertex when declaring it, e.g.:
- *
- * |[
- *   ClutterVertex v = CLUTTER_VERTEX_INIT (x, y, z);
- * ]|
- *
- * Since: 1.10
- */
-#define CLUTTER_VERTEX_INIT(x,y,z)      { (x), (y), (z) }
-
-/**
- * CLUTTER_VERTEX_INIT_ZERO:
- *
- * A simple macro for initializing a #ClutterVertex to (0, 0, 0).
- *
- * Since: 1.12
- */
-#define CLUTTER_VERTEX_INIT_ZERO        CLUTTER_VERTEX_INIT (0.f, 0.f, 0.f)
-
-CLUTTER_EXPORT
-GType          clutter_vertex_get_type (void) G_GNUC_CONST;
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_new      (gfloat               x,
-                                        gfloat               y,
-                                        gfloat               z);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_alloc    (void);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_init     (ClutterVertex       *vertex,
-                                        gfloat               x,
-                                        gfloat               y,
-                                        gfloat               z);
-CLUTTER_EXPORT
-ClutterVertex *clutter_vertex_copy     (const ClutterVertex *vertex);
-CLUTTER_EXPORT
-void           clutter_vertex_free     (ClutterVertex       *vertex);
-CLUTTER_EXPORT
-gboolean       clutter_vertex_equal    (const ClutterVertex *vertex_a,
-                                        const ClutterVertex *vertex_b);
-
 /**
  * ClutterActorBox:
  * @x1: X coordinate of the top left corner
@@ -542,7 +231,7 @@ gboolean         clutter_actor_box_contains      (const ClutterActorBox *box,
                                                   gfloat                 y);
 CLUTTER_EXPORT
 void             clutter_actor_box_from_vertices (ClutterActorBox       *box,
-                                                  const ClutterVertex    verts[]);
+                                                  const graphene_point3d_t verts[]);
 CLUTTER_EXPORT
 void             clutter_actor_box_interpolate   (const ClutterActorBox *initial,
                                                   const ClutterActorBox *final,
@@ -568,41 +257,6 @@ CLUTTER_EXPORT
 void             clutter_actor_box_scale          (ClutterActorBox       *box,
                                                    gfloat                 scale);
 
-/**
- * ClutterGeometry:
- * @x: X coordinate of the top left corner of an actor
- * @y: Y coordinate of the top left corner of an actor
- * @width: width of an actor
- * @height: height of an actor
- *
- * The rectangle containing an actor's bounding box, measured in pixels.
- *
- * You should not use #ClutterGeometry, or operate on its fields
- * directly; you should use #cairo_rectangle_int_t or #ClutterRect if you
- * need a rectangle type, depending on the precision required.
- *
- * Deprecated: 1.16
- */
-struct _ClutterGeometry
-{
-  /*< public >*/
-  gint   x;
-  gint   y;
-  guint  width;
-  guint  height;
-};
-
-CLUTTER_EXPORT
-GType clutter_geometry_get_type (void) G_GNUC_CONST;
-
-CLUTTER_DEPRECATED
-void      clutter_geometry_union      (const ClutterGeometry *geometry_a,
-                                       const ClutterGeometry *geometry_b,
-                                       ClutterGeometry       *result);
-CLUTTER_DEPRECATED
-gboolean  clutter_geometry_intersects (const ClutterGeometry *geometry0,
-                                       const ClutterGeometry *geometry1);
-
 /**
  * ClutterKnot:
  * @x: X coordinate of the knot
@@ -674,10 +328,10 @@ void                clutter_paint_volume_free                (ClutterPaintVolume
 
 CLUTTER_EXPORT
 void                clutter_paint_volume_set_origin          (ClutterPaintVolume       *pv,
-                                                              const ClutterVertex      *origin);
+                                                              const graphene_point3d_t *origin);
 CLUTTER_EXPORT
 void                clutter_paint_volume_get_origin          (const ClutterPaintVolume *pv,
-                                                              ClutterVertex            *vertex);
+                                                              graphene_point3d_t       *vertex);
 CLUTTER_EXPORT
 void                clutter_paint_volume_set_width           (ClutterPaintVolume       *pv,
                                                               gfloat                    width);

clutter/clutter/clutter-util.c

@@ -50,8 +50,8 @@ void
 _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
                                         const CoglMatrix *projection,
                                         const float *viewport,
-                                        const ClutterVertex *vertices_in,
-                                        ClutterVertex *vertices_out,
+                                        const graphene_point3d_t *vertices_in,
+                                        graphene_point3d_t *vertices_out,
                                         int n_vertices)
 {
   CoglMatrix modelview_projection;
@@ -68,7 +68,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
                             modelview);
       cogl_matrix_project_points (&modelview_projection,
                                   3,
-                                  sizeof (ClutterVertex),
+                                  sizeof (graphene_point3d_t),
                                   vertices_in,
                                   sizeof (ClutterVertex4),
                                   vertices_tmp,
@@ -78,7 +78,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
     {
       cogl_matrix_transform_points (modelview,
                                     3,
-                                    sizeof (ClutterVertex),
+                                    sizeof (graphene_point3d_t),
                                     vertices_in,
                                     sizeof (ClutterVertex4),
                                     vertices_tmp,
@@ -96,7 +96,7 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
   for (i = 0; i < n_vertices; i++)
     {
       ClutterVertex4 vertex_tmp = vertices_tmp[i];
-      ClutterVertex *vertex_out = &vertices_out[i];
+      graphene_point3d_t *vertex_out = &vertices_out[i];
       /* Finally translate from OpenGL coords to window coords */
       vertex_out->x = MTX_GL_SCALE_X (vertex_tmp.x, vertex_tmp.w,
                                       viewport[2], viewport[0]);
@@ -106,9 +106,9 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
 }
 
 void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
-                                        ClutterRect                 *dest)
+                                        graphene_rect_t             *dest)
 {
-  *dest = (ClutterRect) {
+  *dest = (graphene_rect_t) {
     .origin = {
       .x = src->x,
       .y = src->y
@@ -120,12 +120,12 @@ void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
   };
 }
 
-void _clutter_util_rectangle_int_extents (const  ClutterRect    *src,
-                                          cairo_rectangle_int_t *dest)
+void _clutter_util_rectangle_int_extents (const  graphene_rect_t *src,
+                                          cairo_rectangle_int_t  *dest)
 {
-  ClutterRect tmp = *src;
+  graphene_rect_t tmp = *src;
 
-  clutter_rect_clamp_to_pixel (&tmp);
+  graphene_rect_round (&tmp, &tmp);
 
   *dest = (cairo_rectangle_int_t) {
     .x = tmp.origin.x,
@@ -210,346 +210,6 @@ _clutter_util_rectangle_intersection (const cairo_rectangle_int_t *src1,
     }
 }
 
-float
-_clutter_util_matrix_determinant (const ClutterMatrix *matrix)
-{
-  return matrix->xw * matrix->yz * matrix->zy * matrix->wz
-       - matrix->xz * matrix->yw * matrix->zy * matrix->wz
-       - matrix->xw * matrix->yy * matrix->zz * matrix->wz
-       + matrix->xy * matrix->yw * matrix->zz * matrix->wz
-       + matrix->xz * matrix->yy * matrix->zw * matrix->wz
-       - matrix->xy * matrix->yz * matrix->zw * matrix->wz
-       - matrix->xw * matrix->yz * matrix->zx * matrix->wy
-       + matrix->xz * matrix->yw * matrix->zx * matrix->wy
-       + matrix->xw * matrix->yx * matrix->zz * matrix->wy
-       - matrix->xx * matrix->yw * matrix->zz * matrix->wy
-       - matrix->xz * matrix->yx * matrix->zw * matrix->wy
-       + matrix->xx * matrix->yz * matrix->zw * matrix->wy
-       + matrix->xw * matrix->yy * matrix->zx * matrix->wz
-       - matrix->xy * matrix->yw * matrix->zx * matrix->wz
-       - matrix->xw * matrix->yx * matrix->zy * matrix->wz
-       + matrix->xx * matrix->yw * matrix->zy * matrix->wz
-       + matrix->xy * matrix->yx * matrix->zw * matrix->wz
-       - matrix->xx * matrix->yy * matrix->zw * matrix->wz
-       - matrix->xz * matrix->yy * matrix->zx * matrix->ww
-       + matrix->xy * matrix->yz * matrix->zx * matrix->ww
-       + matrix->xz * matrix->yx * matrix->zy * matrix->ww
-       - matrix->xx * matrix->yz * matrix->zy * matrix->ww
-       - matrix->xy * matrix->yx * matrix->zz * matrix->ww
-       + matrix->xx * matrix->yy * matrix->zz * matrix->ww;
-}
-
-static void
-_clutter_util_matrix_transpose_vector4_transform (const ClutterMatrix  *matrix,
-                                                  const ClutterVertex4 *point,
-                                                  ClutterVertex4       *res)
-{
-  res->x = matrix->xx * point->x
-         + matrix->xy * point->y
-         + matrix->xz * point->z
-         + matrix->xw * point->w;
-
-  res->y = matrix->yx * point->x
-         + matrix->yy * point->y
-         + matrix->yz * point->z
-         + matrix->yw * point->w;
-
-  res->z = matrix->zx * point->x
-         + matrix->zy * point->y
-         + matrix->zz * point->z
-         + matrix->zw * point->w;
-
-  res->w = matrix->wz * point->x
-         + matrix->wy * point->w
-         + matrix->wz * point->z
-         + matrix->ww * point->w;
-}
-
-void
-_clutter_util_matrix_skew_xy (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->yx += matrix->xx * factor;
-  matrix->yy += matrix->xy * factor;
-  matrix->yz += matrix->xz * factor;
-  matrix->yw += matrix->xw * factor;
-}
-
-void
-_clutter_util_matrix_skew_xz (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->zx += matrix->xx * factor;
-  matrix->zy += matrix->xy * factor;
-  matrix->zz += matrix->xz * factor;
-  matrix->zw += matrix->xw * factor;
-}
-
-void
-_clutter_util_matrix_skew_yz (ClutterMatrix *matrix,
-                              float          factor)
-{
-  matrix->zx += matrix->yx * factor;
-  matrix->zy += matrix->yy * factor;
-  matrix->zz += matrix->yz * factor;
-  matrix->zw += matrix->yw * factor;
-}
-
-static float
-_clutter_util_vertex_length (const ClutterVertex *vertex)
-{
-  return sqrtf (vertex->x * vertex->x + vertex->y * vertex->y + vertex->z * vertex->z);
-}
-
-static void
-_clutter_util_vertex_normalize (ClutterVertex *vertex)
-{
-  float factor = _clutter_util_vertex_length (vertex);
-
-  if (factor == 0.f)
-    return;
-
-  vertex->x /= factor;
-  vertex->y /= factor;
-  vertex->z /= factor;
-}
-
-static float
-_clutter_util_vertex_dot (const ClutterVertex *v1,
-                          const ClutterVertex *v2)
-{
-  return v1->x * v2->x + v1->y * v2->y + v1->z * v2->z;
-}
-
-static void
-_clutter_util_vertex_cross (const ClutterVertex *v1,
-                            const ClutterVertex *v2,
-                            ClutterVertex       *res)
-{
-  res->x = v1->y * v2->z - v2->y * v1->z;
-  res->y = v1->z * v2->x - v2->z * v1->x;
-  res->z = v1->x * v2->y - v2->x * v1->y;
-}
-
-static void
-_clutter_util_vertex_combine (const ClutterVertex *a,
-                              const ClutterVertex *b,
-                              double               ascl,
-                              double               bscl,
-                              ClutterVertex       *res)
-{
-  res->x = (ascl * a->x) + (bscl * b->x);
-  res->y = (ascl * a->y) + (bscl * b->y);
-  res->z = (ascl * a->z) + (bscl * b->z);
-}
-
-void
-_clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
-                                   const ClutterVertex4 *b,
-                                   double                progress,
-                                   ClutterVertex4       *res)
-{
-  res->x = a->x + (b->x - a->x) * progress;
-  res->y = a->y + (b->y - a->y) * progress;
-  res->z = a->z + (b->z - a->z) * progress;
-  res->w = a->w + (b->w - a->w) * progress;
-}
-
-/*< private >
- * clutter_util_matrix_decompose:
- * @src: the matrix to decompose
- * @scale_p: (out caller-allocates): return location for a vertex containing
- *   the scaling factors
- * @shear_p: (out) (array length=3): return location for an array of 3
- *   elements containing the skew factors (XY, XZ, and YZ respectively)
- * @rotate_p: (out caller-allocates): return location for a vertex containing
- *   the Euler angles
- * @translate_p: (out caller-allocates): return location for a vertex
- *   containing the translation vector
- * @perspective_p: (out caller-allocates: return location for a 4D vertex
- *   containing the perspective
- *
- * Decomposes a #ClutterMatrix into the transformations that compose it.
- *
- * This code is based on the matrix decomposition algorithm as published in
- * the CSS Transforms specification by the W3C CSS working group, available
- * at http://www.w3.org/TR/css3-transforms/.
- *
- * The algorithm, in turn, is based on the "unmatrix" method published in
- * "Graphics Gems II, edited by Jim Arvo", which is available at:
- * http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c
- *
- * Return value: %TRUE if the decomposition was successful, and %FALSE
- *   if the matrix is singular
- */
-gboolean
-_clutter_util_matrix_decompose (const ClutterMatrix *src,
-                                ClutterVertex       *scale_p,
-                                float                shear_p[3],
-                                ClutterVertex       *rotate_p,
-                                ClutterVertex       *translate_p,
-                                ClutterVertex4      *perspective_p)
-{
-  CoglMatrix matrix = *src;
-  CoglMatrix perspective;
-  ClutterVertex4 vertex_tmp;
-  ClutterVertex row[3], pdum;
-  int i, j;
-
-#define XY_SHEAR        0
-#define XZ_SHEAR        1
-#define YZ_SHEAR        2
-#define MAT(m,r,c)      ((float *)(m))[(c) * 4 + (r)]
-
-  /* normalize the matrix */
-  if (matrix.ww == 0.f)
-    return FALSE;
-
-  for (i = 0; i < 4; i++)
-    {
-      for (j = 0; j < 4; j++)
-        {
-          MAT (&matrix, j, i) /= MAT (&matrix, 3, 3);
-        }
-    }
-
-  /* perspective is used to solve for perspective, but it also provides
-   * an easy way to test for singularity of the upper 3x3 component
-   */
-  perspective = matrix;
-
-  /* transpose */
-  MAT (&perspective, 3, 0) = 0.f;
-  MAT (&perspective, 3, 1) = 0.f;
-  MAT (&perspective, 3, 2) = 0.f;
-  MAT (&perspective, 3, 3) = 1.f;
-
-  if (_clutter_util_matrix_determinant (&perspective) == 0.f)
-    return FALSE;
-
-  if (MAT (&matrix, 3, 0) != 0.f ||
-      MAT (&matrix, 3, 1) != 0.f ||
-      MAT (&matrix, 3, 2) != 0.f)
-    {
-      CoglMatrix perspective_inv;
-      ClutterVertex4 p;
-
-      vertex_tmp.x = MAT (&matrix, 3, 0);
-      vertex_tmp.y = MAT (&matrix, 3, 1);
-      vertex_tmp.z = MAT (&matrix, 3, 2);
-      vertex_tmp.w = MAT (&matrix, 3, 3);
-
-      /* solve the equation by inverting perspective... */
-      cogl_matrix_get_inverse (&perspective, &perspective_inv);
-
-      /* ... and multiplying vertex_tmp by the inverse */
-      _clutter_util_matrix_transpose_vector4_transform (&perspective_inv,
-                                                        &vertex_tmp,
-                                                        &p);
-
-      *perspective_p = p;
-
-      /* clear the perspective part */
-      MAT (&matrix, 3, 0) = 0.0f;
-      MAT (&matrix, 3, 1) = 0.0f;
-      MAT (&matrix, 3, 2) = 0.0f;
-      MAT (&matrix, 3, 3) = 1.0f;
-    }
-  else
-    {
-      /* no perspective */
-      perspective_p->x = 0.0f;
-      perspective_p->y = 0.0f;
-      perspective_p->z = 0.0f;
-      perspective_p->w = 1.0f;
-    }
-
-  /* translation */
-  translate_p->x = MAT (&matrix, 0, 3);
-  MAT (&matrix, 0, 3) = 0.f;
-  translate_p->y = MAT (&matrix, 1, 3);
-  MAT (&matrix, 1, 3) = 0.f;
-  translate_p->z = MAT (&matrix, 2, 3);
-  MAT (&matrix, 2, 3) = 0.f;
-
-  /* scale and shear; we split the upper 3x3 matrix into rows */
-  for (i = 0; i < 3; i++)
-    {
-      row[i].x = MAT (&matrix, i, 0);
-      row[i].y = MAT (&matrix, i, 1);
-      row[i].z = MAT (&matrix, i, 2);
-    }
-
-  /* compute scale.x and normalize the first row */
-  scale_p->x = _clutter_util_vertex_length (&row[0]);
-  _clutter_util_vertex_normalize (&row[0]);
-
-  /* compute XY shear and make the second row orthogonal to the first */
-  shear_p[XY_SHEAR] = _clutter_util_vertex_dot (&row[0], &row[1]);
-  _clutter_util_vertex_combine (&row[1], &row[0],
-                                1.0, -shear_p[XY_SHEAR],
-                                &row[1]);
-
-  /* compute the Y scale and normalize the second row */
-  scale_p->y = _clutter_util_vertex_length (&row[1]);
-  _clutter_util_vertex_normalize (&row[1]);
-  shear_p[XY_SHEAR] /= scale_p->y;
-
-  /* compute XZ and YZ shears, orthogonalize the third row */
-  shear_p[XZ_SHEAR] = _clutter_util_vertex_dot (&row[0], &row[2]);
-  _clutter_util_vertex_combine (&row[2], &row[0],
-                                1.0, -shear_p[XZ_SHEAR],
-                                &row[2]);
-
-  shear_p[YZ_SHEAR] = _clutter_util_vertex_dot (&row[1], &row[2]);
-  _clutter_util_vertex_combine (&row[2], &row[1],
-                                1.0, -shear_p[YZ_SHEAR],
-                                &row[2]);
-
-  /* get the Z scale and normalize the third row*/
-  scale_p->z = _clutter_util_vertex_length (&row[2]);
-  _clutter_util_vertex_normalize (&row[2]);
-  shear_p[XZ_SHEAR] /= scale_p->z;
-  shear_p[YZ_SHEAR] /= scale_p->z;
-
-  /* at this point, the matrix (inside row[]) is orthonormal.
-   * check for a coordinate system flip; if the determinant
-   * is -1, then negate the matrix and scaling factors
-   */
-  _clutter_util_vertex_cross (&row[1], &row[2], &pdum);
-  if (_clutter_util_vertex_dot (&row[0], &pdum) < 0.f)
-    {
-      scale_p->x *= -1.f;
-
-      for (i = 0; i < 3; i++)
-        {
-          row[i].x *= -1.f;
-          row[i].y *= -1.f;
-          row[i].z *= -1.f;
-        }
-    }
-
-  /* now get the rotations out */
-  rotate_p->y = asinf (-row[0].z);
-  if (cosf (rotate_p->y) != 0.f)
-    {
-      rotate_p->x = atan2f (row[1].z, row[2].z);
-      rotate_p->z = atan2f (row[0].y, row[0].x);
-    }
-  else
-    {
-      rotate_p->x = atan2f (-row[2].x, row[1].y);
-      rotate_p->z = 0.f;
-    }
-
-#undef XY_SHEAR
-#undef XZ_SHEAR
-#undef YZ_SHEAR
-#undef MAT
-
-  return TRUE;
-}
-
 typedef struct
 {
   GType value_type;

clutter/clutter/clutter-zoom-action.c

@@ -80,9 +80,9 @@ struct _ClutterZoomActionPrivate
 
   ZoomPoint points[2];
 
-  ClutterPoint initial_focal_point;
-  ClutterPoint focal_point;
-  ClutterPoint transformed_focal_point;
+  graphene_point_t initial_focal_point;
+  graphene_point_t focal_point;
+  graphene_point_t transformed_focal_point;
 
   gfloat initial_x;
   gfloat initial_y;
@@ -238,13 +238,13 @@ clutter_zoom_action_gesture_cancel (ClutterGestureAction *action,
 static gboolean
 clutter_zoom_action_real_zoom (ClutterZoomAction *action,
                                ClutterActor      *actor,
-                               ClutterPoint      *focal_point,
+                               graphene_point_t  *focal_point,
                                gdouble            factor)
 {
   ClutterZoomActionPrivate *priv = action->priv;
   gfloat x, y, z;
   gdouble scale_x, scale_y;
-  ClutterVertex out, in;
+  graphene_point3d_t out, in;
 
   in.x = priv->transformed_focal_point.x;
   in.y = priv->transformed_focal_point.y;
@@ -400,7 +400,7 @@ clutter_zoom_action_class_init (ClutterZoomActionClass *klass)
                   _clutter_marshal_BOOLEAN__OBJECT_BOXED_DOUBLE,
                   G_TYPE_BOOLEAN, 3,
                   CLUTTER_TYPE_ACTOR,
-                  CLUTTER_TYPE_POINT,
+                  GRAPHENE_TYPE_POINT,
                   G_TYPE_DOUBLE);
 }
 
@@ -478,7 +478,7 @@ clutter_zoom_action_get_zoom_axis (ClutterZoomAction *action)
 /**
  * clutter_zoom_action_get_focal_point:
  * @action: a #ClutterZoomAction
- * @point: (out): a #ClutterPoint
+ * @point: (out): a #graphene_point_t
  *
  * Retrieves the focal point of the current zoom
  *
@@ -486,7 +486,7 @@ clutter_zoom_action_get_zoom_axis (ClutterZoomAction *action)
  */
 void
 clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
-                                     ClutterPoint      *point)
+                                     graphene_point_t  *point)
 {
   g_return_if_fail (CLUTTER_IS_ZOOM_ACTION (action));
   g_return_if_fail (point != NULL);
@@ -497,7 +497,7 @@ clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
 /**
  * clutter_zoom_action_get_transformed_focal_point:
  * @action: a #ClutterZoomAction
- * @point: (out): a #ClutterPoint
+ * @point: (out): a #graphene_point_t
  *
  * Retrieves the focal point relative to the actor's coordinates of
  * the current zoom
@@ -506,7 +506,7 @@ clutter_zoom_action_get_focal_point (ClutterZoomAction *action,
  */
 void
 clutter_zoom_action_get_transformed_focal_point (ClutterZoomAction *action,
-                                                 ClutterPoint      *point)
+                                                 graphene_point_t  *point)
 {
   g_return_if_fail (CLUTTER_IS_ZOOM_ACTION (action));
   g_return_if_fail (point != NULL);

clutter/clutter/clutter-zoom-action.h

@@ -79,7 +79,7 @@ struct _ClutterZoomActionClass
   /*< public >*/
   gboolean (* zoom)  (ClutterZoomAction *action,
                       ClutterActor      *actor,
-                      ClutterPoint      *focal_point,
+                      graphene_point_t  *focal_point,
                       gdouble            factor);
 
   /*< private >*/
@@ -104,10 +104,10 @@ ClutterZoomAxis clutter_zoom_action_get_zoom_axis               (ClutterZoomActi
 
 CLUTTER_EXPORT
 void            clutter_zoom_action_get_focal_point             (ClutterZoomAction *action,
-                                                                 ClutterPoint      *point);
+                                                                 graphene_point_t  *point);
 CLUTTER_EXPORT
 void            clutter_zoom_action_get_transformed_focal_point (ClutterZoomAction *action,
-                                                                 ClutterPoint      *point);
+                                                                 graphene_point_t  *point);
 
 G_END_DECLS
 

clutter/clutter/cogl/clutter-stage-cogl.c

@@ -576,14 +576,14 @@ is_buffer_age_enabled (void)
 }
 
 static void
-scale_and_clamp_rect (const ClutterRect     *rect,
+scale_and_clamp_rect (const graphene_rect_t *rect,
                       float                  scale,
                       cairo_rectangle_int_t *dest)
 
 {
-  ClutterRect tmp = *rect;
+  graphene_rect_t tmp = *rect;
 
-  clutter_rect_scale (&tmp, scale, scale);
+  graphene_rect_scale (&tmp, scale, scale, &tmp);
   _clutter_util_rectangle_int_extents (&tmp, dest);
 }
 
@@ -650,12 +650,12 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
        * frames when starting up... */
       cogl_onscreen_get_frame_counter (COGL_ONSCREEN (fb)) > 3)
     {
-      ClutterRect rect;
+      graphene_rect_t rect;
 
       may_use_clipped_redraw = TRUE;
 
       _clutter_util_rect_from_rectangle (&redraw_clip, &rect);
-      clutter_rect_offset (&rect, -view_rect.x, -view_rect.y);
+      graphene_rect_offset (&rect, -view_rect.x, -view_rect.y);
       scale_and_clamp_rect (&rect, fb_scale, &fb_clip_region);
 
       if (fb_scale != floorf (fb_scale))
@@ -693,7 +693,7 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
 
           if (valid_buffer_age (view_cogl, age))
             {
-              ClutterRect rect;
+              graphene_rect_t rect;
               cairo_rectangle_int_t damage_region;
 
               *current_fb_damage = fb_clip_region;
@@ -753,7 +753,7 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
     }
   else if (use_clipped_redraw)
     {
-      ClutterRect rect;
+      graphene_rect_t rect;
       cairo_rectangle_int_t scissor_rect;
       cairo_rectangle_int_t paint_rect;
 
@@ -799,7 +799,7 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
           may_use_clipped_redraw &&
           !clip_region_empty)
         {
-          ClutterRect rect;
+          graphene_rect_t rect;
           cairo_rectangle_int_t scissor_rect;
           cairo_rectangle_int_t paint_rect;
 

clutter/clutter/deprecated/clutter-actor-deprecated.c

@@ -1,44 +0,0 @@
-#include "clutter-build-config.h"
-
-#include <glib-object.h>
-
-#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
-#include "deprecated/clutter-actor.h"
-
-#include "clutter-actor-private.h"
-#include "clutter-private.h"
-
-/**
- * clutter_actor_get_allocation_geometry:
- * @self: A #ClutterActor
- * @geom: (out): allocation geometry in pixels
- *
- * Gets the layout box an actor has been assigned.  The allocation can
- * only be assumed valid inside a paint() method; anywhere else, it
- * may be out-of-date.
- *
- * An allocation does not incorporate the actor's scale or anchor point;
- * those transformations do not affect layout, only rendering.
- *
- * The returned rectangle is in pixels.
- *
- * Since: 0.8
- *
- * Deprecated: 1.12: Use clutter_actor_get_allocation_box() instead.
- */
-void
-clutter_actor_get_allocation_geometry (ClutterActor    *self,
-                                       ClutterGeometry *geom)
-{
-  ClutterActorBox box;
-
-  g_return_if_fail (CLUTTER_IS_ACTOR (self));
-  g_return_if_fail (geom != NULL);
-
-  clutter_actor_get_allocation_box (self, &box);
-
-  geom->x = CLUTTER_NEARBYINT (clutter_actor_box_get_x (&box));
-  geom->y = CLUTTER_NEARBYINT (clutter_actor_box_get_y (&box));
-  geom->width = CLUTTER_NEARBYINT (clutter_actor_box_get_width (&box));
-  geom->height = CLUTTER_NEARBYINT (clutter_actor_box_get_height (&box));
-}

clutter/clutter/deprecated/clutter-actor.h

@@ -145,10 +145,6 @@ CLUTTER_DEPRECATED
 void            clutter_actor_get_transformation_matrix         (ClutterActor          *self,
                                                                  ClutterMatrix         *matrix);
 
-CLUTTER_DEPRECATED_FOR (clutter_actor_get_allocation_box)
-void            clutter_actor_get_allocation_geometry           (ClutterActor          *self,
-                                                                 ClutterGeometry       *geom);
-
 G_END_DECLS
 
 #endif /* __CLUTTER_ACTOR_DEPRECATED_H__ */

clutter/clutter/deprecated/clutter-animation.c

@@ -2222,7 +2222,7 @@ clutter_actor_animate_with_timeline (ClutterActor    *actor,
  *
  * Will animate the "rotation-angle-z" property between the current value
  * and 360 degrees, and set the "rotation-center-z" property to the fixed
- * value of the #ClutterVertex "center".
+ * value of the #graphene_point3d_t "center".
  *
  * This function will implicitly create a #ClutterAnimation object which
  * will be assigned to the @actor and will be returned to the developer

clutter/clutter/deprecated/clutter-rectangle.c

@@ -84,7 +84,7 @@ clutter_rectangle_paint (ClutterActor *self)
   CoglFramebuffer *framebuffer = cogl_get_draw_framebuffer ();
   static CoglPipeline *default_color_pipeline = NULL;
   CoglPipeline *content_pipeline;
-  ClutterGeometry geom;
+  ClutterActorBox alloc;
   CoglColor color;
   guint8 tmp_alpha;
 
@@ -92,7 +92,7 @@ clutter_rectangle_paint (ClutterActor *self)
                 "painting rect '%s'",
 		clutter_actor_get_name (self) ? clutter_actor_get_name (self)
                                               : "unknown");
-  clutter_actor_get_allocation_geometry (self, &geom);
+  clutter_actor_get_allocation_box (self, &alloc);
 
   if (G_UNLIKELY (default_color_pipeline == NULL))
     {
@@ -140,40 +140,41 @@ clutter_rectangle_paint (ClutterActor *self)
       /* We paint the border and the content only if the rectangle
        * is big enough to show them
        */
-      if ((priv->border_width * 2) < geom.width &&
-          (priv->border_width * 2) < geom.height)
+      if ((priv->border_width * 2) < clutter_actor_box_get_width (&alloc) &&
+          (priv->border_width * 2) < clutter_actor_box_get_height (&alloc))
         {
           /* paint the border. this sucks, but it's the only way to make a border */
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            border_pipeline,
                                            priv->border_width, 0,
-                                           geom.width,
+                                           clutter_actor_box_get_width (&alloc),
                                            priv->border_width);
 
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            border_pipeline,
-                                           geom.width - priv->border_width,
+                                           clutter_actor_box_get_width (&alloc) - priv->border_width,
                                            priv->border_width,
-                                           geom.width, geom.height);
+                                           clutter_actor_box_get_width (&alloc),
+                                           clutter_actor_box_get_height (&alloc));
 
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            border_pipeline,
-                                           0, geom.height - priv->border_width,
-                                           geom.width - priv->border_width,
-                                           geom.height);
+                                           0, clutter_actor_box_get_height (&alloc) - priv->border_width,
+                                           clutter_actor_box_get_width (&alloc) - priv->border_width,
+                                           clutter_actor_box_get_height (&alloc));
 
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            border_pipeline,
                                            0, 0,
                                            priv->border_width,
-                                           geom.height - priv->border_width);
+                                           clutter_actor_box_get_height (&alloc) - priv->border_width);
 
           /* now paint the rectangle */
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            content_pipeline,
                                            priv->border_width, priv->border_width,
-                                           geom.width - priv->border_width,
-                                           geom.height - priv->border_width);
+                                           clutter_actor_box_get_width (&alloc) - priv->border_width,
+                                           clutter_actor_box_get_height (&alloc) - priv->border_width);
         }
       else
         {
@@ -183,7 +184,9 @@ clutter_rectangle_paint (ClutterActor *self)
            */
           cogl_framebuffer_draw_rectangle (framebuffer,
                                            border_pipeline,
-                                           0, 0, geom.width, geom.height);
+                                           0, 0,
+                                           clutter_actor_box_get_width (&alloc),
+                                           clutter_actor_box_get_height (&alloc));
         }
 
       cogl_object_unref (border_pipeline);
@@ -192,7 +195,9 @@ clutter_rectangle_paint (ClutterActor *self)
     {
       cogl_framebuffer_draw_rectangle (framebuffer,
                                        content_pipeline,
-                                       0, 0, geom.width, geom.height);
+                                       0, 0,
+                                       clutter_actor_box_get_width (&alloc),
+                                       clutter_actor_box_get_height (&alloc));
     }
 
   cogl_object_unref (content_pipeline);

clutter/clutter/deprecated/clutter-stage.h

@@ -74,20 +74,6 @@ gboolean        clutter_stage_is_default        (ClutterStage       *stage);
 CLUTTER_DEPRECATED_FOR(clutter_actor_queue_redraw)
 void            clutter_stage_queue_redraw      (ClutterStage       *stage);
 
-CLUTTER_DEPRECATED
-void            clutter_stage_set_use_fog       (ClutterStage       *stage,
-                                                 gboolean            fog);
-
-CLUTTER_DEPRECATED
-gboolean        clutter_stage_get_use_fog       (ClutterStage       *stage);
-
-CLUTTER_DEPRECATED
-void            clutter_stage_set_fog           (ClutterStage       *stage,
-                                                 ClutterFog         *fog);
-
-CLUTTER_DEPRECATED
-void            clutter_stage_get_fog           (ClutterStage       *stage,
-                                                 ClutterFog         *fog);
 
 CLUTTER_DEPRECATED_FOR(clutter_actor_set_background_color)
 void            clutter_stage_set_color         (ClutterStage       *stage,

clutter/clutter/deprecated/clutter-texture.c

@@ -438,7 +438,7 @@ set_viewport_with_buffer_under_fbo_source (ClutterActor *fbo_source,
        * falling back to a stage sized fbo with an offset of (0,0)
        */
 
-      ClutterVertex verts[4];
+      graphene_point3d_t verts[4];
       float x_min = G_MAXFLOAT, y_min = G_MAXFLOAT;
       int i;
 

clutter/clutter/evdev/clutter-device-manager-evdev.c

@@ -405,7 +405,7 @@ notify_pinch_gesture_event (ClutterInputDevice          *input_device,
   ClutterSeatEvdev *seat;
   ClutterStage *stage;
   ClutterEvent *event = NULL;
-  ClutterPoint pos;
+  graphene_point_t pos;
 
   /* We can drop the event on the floor if no stage has been
    * associated with the device yet. */
@@ -452,7 +452,7 @@ notify_swipe_gesture_event (ClutterInputDevice          *input_device,
   ClutterSeatEvdev *seat;
   ClutterStage *stage;
   ClutterEvent *event = NULL;
-  ClutterPoint pos;
+  graphene_point_t pos;
 
   /* We can drop the event on the floor if no stage has been
    * associated with the device yet. */

clutter/clutter/evdev/clutter-seat-evdev.c

@@ -568,7 +568,7 @@ clutter_seat_evdev_notify_button (ClutterSeatEvdev   *seat,
 
   if (clutter_input_device_get_device_type (input_device) == CLUTTER_TABLET_DEVICE)
     {
-      ClutterPoint point;
+      graphene_point_t point;
 
       clutter_input_device_get_coords (input_device, NULL, &point);
       event->button.x = point.x;

clutter/clutter/evdev/clutter-seat-evdev.h

@@ -42,7 +42,7 @@ struct _ClutterTouchState
 
   int device_slot;
   int seat_slot;
-  ClutterPoint coords;
+  graphene_point_t coords;
 };
 
 struct _ClutterSeatEvdev

clutter/clutter/meson.build

@@ -127,6 +127,7 @@ clutter_sources = [
   'clutter-flatten-effect.c',
   'clutter-flow-layout.c',
   'clutter-gesture-action.c',
+  'clutter-graphene.c',
   'clutter-grid-layout.c',
   'clutter-image.c',
   'clutter-input-device.c',
@@ -191,6 +192,7 @@ clutter_private_headers = [
   'clutter-event-translator.h',
   'clutter-event-private.h',
   'clutter-flatten-effect.h',
+  'clutter-graphene.h',
   'clutter-gesture-action-private.h',
   'clutter-id-pool.h',
   'clutter-input-focus-private.h',
@@ -242,7 +244,6 @@ clutter_deprecated_headers = [
 ]
 
 clutter_deprecated_sources = [
-  'deprecated/clutter-actor-deprecated.c',
   'deprecated/clutter-alpha.c',
   'deprecated/clutter-animation.c',
   'deprecated/clutter-behaviour.c',
@@ -501,6 +502,7 @@ libmutter_clutter = shared_library(libmutter_clutter_name,
 libmutter_clutter_dep = declare_dependency(
   sources: [clutter_enum_types[1]],
   link_with: libmutter_clutter,
+  dependencies: clutter_deps,
 )
 
 if have_introspection

clutter/tests/accessibility/cally-atktext-example.c

@@ -40,7 +40,7 @@ test_atk_text (ClutterActor *actor)
   gchar           *text       = NULL;
   AtkObject       *object     = NULL;
   AtkText         *cally_text = NULL;
-  gboolean         bool       = FALSE;
+  gboolean         boolean    = FALSE;
   gunichar         unichar;
   gint             count      = -1;
   gint             start      = -1;
@@ -89,17 +89,17 @@ test_atk_text (ClutterActor *actor)
   g_print ("atk_text_get_selection: %s, %i, %i\n", text, start, end);
   g_free(text); text = NULL;
 
-  bool = atk_text_remove_selection (cally_text, 0);
-  g_print ("atk_text_remove_selection (0): %i\n", bool);
+  boolean = atk_text_remove_selection (cally_text, 0);
+  g_print ("atk_text_remove_selection (0): %i\n", boolean);
 
-  bool = atk_text_remove_selection (cally_text, 1);
-  g_print ("atk_text_remove_selection (1): %i\n", bool);
+  boolean = atk_text_remove_selection (cally_text, 1);
+  g_print ("atk_text_remove_selection (1): %i\n", boolean);
 
-  bool = atk_text_add_selection (cally_text, 5, 10);
-  g_print ("atk_text_add_selection: %i\n", bool);
+  boolean = atk_text_add_selection (cally_text, 5, 10);
+  g_print ("atk_text_add_selection: %i\n", boolean);
 
-  bool = atk_text_set_selection (cally_text, 0, 6, 10);
-  g_print ("atk_text_set_selection: %i\n", bool);
+  boolean = atk_text_set_selection (cally_text, 0, 6, 10);
+  g_print ("atk_text_set_selection: %i\n", boolean);
 
   at_set = atk_text_get_run_attributes (cally_text, 0,
                                         &start, &end);

clutter/tests/conform/actor-anchors.c

@@ -99,7 +99,7 @@ notify_cb (GObject *object, GParamSpec *pspec, TestState *state)
    macro so that the assertion failure will report the right line
    number */
 #define assert_coords(state, x_1, y_1, x_2, y_2)        G_STMT_START {  \
-  ClutterVertex verts[4];                                               \
+  graphene_point3d_t verts[4];                                          \
   clutter_actor_get_abs_allocation_vertices ((state)->rect, verts);     \
   check_coords ((state), (x_1), (y_1), (x_2), (y_2), verts);            \
   g_assert (approx_equal ((x_1), verts[0].x));                          \
@@ -114,7 +114,7 @@ notify_cb (GObject *object, GParamSpec *pspec, TestState *state)
   g_assert (approx_equal (v->x, xc) &&                          \
             approx_equal (v->y, yc) &&                          \
             approx_equal (v->z, zc));                           \
-  g_boxed_free (CLUTTER_TYPE_VERTEX, v);        } G_STMT_END
+  g_boxed_free (GRAPHENE_TYPE_POINT3D, v);        } G_STMT_END
 
 static inline gboolean
 approx_equal (int a, int b)
@@ -128,7 +128,7 @@ check_coords (TestState *state,
               gint y_1,
               gint x_2,
               gint y_2,
-              const ClutterVertex *verts)
+              const graphene_point3d_t *verts)
 {
   if (g_test_verbose ())
     g_print ("checking that (%i,%i,%i,%i) \xe2\x89\x88 (%i,%i,%i,%i): %s\n",
@@ -424,7 +424,7 @@ test_rotate_center (TestState *state)
 {
   ClutterActor *rect = state->rect;
   gdouble angle_x, angle_y, angle_z;
-  ClutterVertex *center_x, *center_y, *center_z;
+  graphene_point3d_t *center_x, *center_y, *center_z;
   ClutterGravity z_center_gravity;
   gfloat stage_width, stage_height;
   gfloat rect_x, rect_y;

clutter/tests/conform/actor-layout.c

@@ -6,7 +6,7 @@ actor_basic_layout (void)
   ClutterActor *stage = clutter_test_get_stage ();
   ClutterActor *vase;
   ClutterActor *flower[3];
-  ClutterPoint p;
+  graphene_point_t p;
 
   vase = clutter_actor_new ();
   clutter_actor_set_name (vase, "Vase");
@@ -31,13 +31,13 @@ actor_basic_layout (void)
   clutter_actor_set_name (flower[2], "Green Flower");
   clutter_actor_add_child (vase, flower[2]);
 
-  clutter_point_init (&p, 50, 50);
+  graphene_point_init (&p, 50, 50);
   clutter_test_assert_actor_at_point (stage, &p, flower[0]);
 
-  clutter_point_init (&p, 150, 50);
+  graphene_point_init (&p, 150, 50);
   clutter_test_assert_actor_at_point (stage, &p, flower[1]);
 
-  clutter_point_init (&p, 250, 50);
+  graphene_point_init (&p, 250, 50);
   clutter_test_assert_actor_at_point (stage, &p, flower[2]);
 }
 
@@ -47,7 +47,7 @@ actor_margin_layout (void)
   ClutterActor *stage = clutter_test_get_stage ();
   ClutterActor *vase;
   ClutterActor *flower[3];
-  ClutterPoint p;
+  graphene_point_t p;
 
   vase = clutter_actor_new ();
   clutter_actor_set_name (vase, "Vase");
@@ -76,13 +76,13 @@ actor_margin_layout (void)
   clutter_actor_set_margin_bottom (flower[2], 6);
   clutter_actor_add_child (vase, flower[2]);
 
-  clutter_point_init (&p, 0, 7);
+  graphene_point_init (&p, 0, 7);
   clutter_test_assert_actor_at_point (stage, &p, flower[0]);
 
-  clutter_point_init (&p, 106, 50);
+  graphene_point_init (&p, 106, 50);
   clutter_test_assert_actor_at_point (stage, &p, flower[1]);
 
-  clutter_point_init (&p, 212, 7);
+  graphene_point_init (&p, 212, 7);
   clutter_test_assert_actor_at_point (stage, &p, flower[2]);
 }
 

clutter/tests/interactive/test-events.c

@@ -240,7 +240,7 @@ input_cb (ClutterActor *actor,
 {
   ClutterActor *stage = clutter_actor_get_stage (actor); 
   ClutterActor *source_actor = clutter_event_get_source (event);
-  ClutterPoint position;
+  graphene_point_t position;
   gchar *state;
   gchar keybuf[128];
   gint device_id;

clutter/tests/interactive/test-layout.c

@@ -334,7 +334,7 @@ my_thing_allocate (ClutterActor           *self,
           if (clutter_actor_is_scaled (child) ||
               clutter_actor_is_rotated (child))
             {
-              ClutterVertex v1 = { 0, }, v2 = { 0, };
+              graphene_point3d_t v1 = { 0, }, v2 = { 0, };
               ClutterActorBox transformed_box = { 0, };
 
               /* origin */

clutter/tests/interactive/test-texture-quality.c

@@ -54,7 +54,6 @@ test_texture_quality_main (int argc, char *argv[])
   ClutterActor     *stage;
   ClutterActor     *image;
   ClutterColor      stage_color = { 0x12, 0x34, 0x56, 0xff };
-  ClutterFog        stage_fog = { 10.0, -50.0 };
   GError           *error;
   gchar            *file;
 
@@ -63,8 +62,6 @@ test_texture_quality_main (int argc, char *argv[])
 
   stage = clutter_stage_new ();
   clutter_actor_set_background_color (stage, &stage_color);
-  clutter_stage_set_use_fog (CLUTTER_STAGE (stage), TRUE);
-  clutter_stage_set_fog (CLUTTER_STAGE (stage), &stage_fog);
   g_signal_connect (stage,
                     "destroy", G_CALLBACK (clutter_main_quit),
                     NULL);

cogl/cogl/cogl-context-private.h

@@ -152,8 +152,6 @@ struct _CoglContext
   GArray           *texture_units;
   int               active_texture_unit;
 
-  CoglPipelineFogState legacy_fog_state;
-
   /* Pipelines */
   CoglPipeline     *opaque_color_pipeline; /* used for set_source_color */
   CoglPipeline     *blended_color_pipeline; /* used for set_source_color */

cogl/cogl/cogl-context.c

@@ -310,8 +310,6 @@ cogl_context_new (CoglDisplay *display,
       GE (context, glActiveTexture (GL_TEXTURE1));
     }
 
-  context->legacy_fog_state.enabled = FALSE;
-
   context->opaque_color_pipeline = cogl_pipeline_new (context);
   context->blended_color_pipeline = cogl_pipeline_new (context);
   context->texture_pipeline = cogl_pipeline_new (context);

cogl/cogl/cogl-euler.c

@@ -1,196 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#include "cogl-config.h"
-
-#include <cogl-util.h>
-#include <cogl-euler.h>
-#include <cogl-matrix.h>
-#include "cogl-gtype-private.h"
-
-#include <math.h>
-#include <string.h>
-
-COGL_GTYPE_DEFINE_BOXED (Euler, euler,
-                         cogl_euler_copy,
-                         cogl_euler_free);
-
-void
-cogl_euler_init (CoglEuler *euler,
-                 float heading,
-                 float pitch,
-                 float roll)
-{
-  euler->heading = heading;
-  euler->pitch = pitch;
-  euler->roll = roll;
-}
-
-void
-cogl_euler_init_from_matrix (CoglEuler *euler,
-                             const CoglMatrix *matrix)
-{
-  /*
-   * Extracting a canonical Euler angle from a matrix:
-   * (where it is assumed the matrix contains no scaling, mirroring or
-   *  skewing)
-   *
-   * A Euler angle is a combination of three rotations around mutually
-   * perpendicular axis. For this algorithm they are:
-   *
-   * Heading: A rotation about the Y axis by an angle H:
-   * | cosH  0  sinH|
-   * |    0  1     0|
-   * |-sinH  0  cosH|
-   *
-   * Pitch: A rotation around the X axis by an angle P:
-   * |1     0      0|
-   * |0  cosP  -sinP|
-   * |0  sinP   cosP|
-   *
-   * Roll: A rotation about the Z axis by an angle R:
-   * |cosR -sinR  0|
-   * |sinR  cosR  0|
-   * |   0     0  1|
-   *
-   * When multiplied as matrices this gives:
-   *     | cosHcosR+sinHsinPsinR   sinRcosP  -sinHcosR+cosHsinPsinR|
-   * M = |-cosHsinR+sinHsinPcosR   cosRcosP   sinRsinH+cosHsinPcosB|
-   *     | sinHcosP               -sinP       cosHcosP             |
-   *
-   * Given that there are an infinite number of ways to represent
-   * a given orientation, the "canonical" Euler angle is any such that:
-   *  -180 < H < 180,
-   *  -180 < R < 180 and
-   *   -90 < P < 90
-   *
-   * M[3][2] = -sinP lets us immediately solve for P = asin(-M[3][2])
-   *   (Note: asin has a range of +-90)
-   * This gives cosP
-   * This means we can use M[3][1] to calculate sinH:
-   *   sinH = M[3][1]/cosP
-   * And use M[3][3] to calculate cosH:
-   *   cosH = M[3][3]/cosP
-   * This lets us calculate H = atan2(sinH,cosH), but we optimise this:
-   *   1st note: atan2(x, y) does: atan(x/y) and uses the sign of x and y to
-   *   determine the quadrant of the final angle.
-   *   2nd note: we know cosP is > 0 (ignoring cosP == 0)
-   *   Therefore H = atan2((M[3][1]/cosP) / (M[3][3]/cosP)) can be simplified
-   *   by skipping the division by cosP since it won't change the x/y ratio
-   *   nor will it change their sign. This gives:
-   *     H = atan2(M[3][1], M[3][3])
-   * R is computed in the same way as H from M[1][2] and M[2][2] so:
-   *     R = atan2(M[1][2], M[2][2])
-   * Note: If cosP were == 0 then H and R could not be calculated as above
-   * because all the necessary matrix values would == 0. In other words we are
-   * pitched vertically and so H and R would now effectively rotate around the
-   * same axis - known as "Gimbal lock". In this situation we will set all the
-   * rotation on H and set R = 0.
-   *   So with P = R = 0 we have cosP = 0, sinR = 0 and cosR = 1
-   *   We can substitute those into the above equation for M giving:
-   *   |    cosH      0     -sinH|
-   *   |sinHsinP      0  cosHsinP|
-   *   |       0  -sinP         0|
-   *   And calculate H as atan2 (-M[3][2], M[1][1])
-   */
-
-  float sinP;
-  float H; /* heading */
-  float P; /* pitch */
-  float R; /* roll */
-
-  /* NB: CoglMatrix provides struct members named according to the
-   * [row][column] indexed. So matrix->zx is row 3 column 1. */
-  sinP = -matrix->zy;
-
-  /* Determine the Pitch, avoiding domain errors with asin () which
-   * might occur due to previous imprecision in manipulating the
-   * matrix. */
-  if (sinP <= -1.0f)
-    P = -G_PI_2;
-  else if (sinP >= 1.0f)
-    P = G_PI_2;
-  else
-    P = asinf (sinP);
-
-  /* If P is too close to 0 then we have hit Gimbal lock */
-  if (sinP > 0.999f)
-    {
-      H = atan2f (-matrix->zy, matrix->xx);
-      R = 0;
-    }
-  else
-    {
-      H = atan2f (matrix->zx, matrix->zz);
-      R = atan2f (matrix->xy, matrix->yy);
-    }
-
-  euler->heading = H;
-  euler->pitch = P;
-  euler->roll = R;
-}
-
-gboolean
-cogl_euler_equal (const void *v1, const void *v2)
-{
-  const CoglEuler *a = v1;
-  const CoglEuler *b = v2;
-
-  _COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
-  _COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
-
-  if (v1 == v2)
-    return TRUE;
-
-  return (a->heading == b->heading &&
-          a->pitch == b->pitch &&
-          a->roll == b->roll);
-}
-
-CoglEuler *
-cogl_euler_copy (const CoglEuler *src)
-{
-  if (G_LIKELY (src))
-    {
-      CoglEuler *new = g_slice_new (CoglEuler);
-      memcpy (new, src, sizeof (float) * 3);
-      return new;
-    }
-  else
-    return NULL;
-}
-
-void
-cogl_euler_free (CoglEuler *euler)
-{
-  g_slice_free (CoglEuler, euler);
-}
-

cogl/cogl/cogl-euler.h

@@ -1,265 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_EULER_H
-#define __COGL_EULER_H
-
-#include <cogl/cogl-types.h>
-
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-euler
- * @short_description: Functions for initializing and manipulating
- * euler angles.
- *
- * Euler angles are a simple representation of a 3 dimensional
- * rotation; comprised of 3 ordered heading, pitch and roll rotations.
- * An important thing to understand is that the axis of rotation
- * belong to the object being rotated and so they also rotate as each
- * of the heading, pitch and roll rotations are applied.
- *
- * One way to consider euler angles is to imagine controlling an
- * aeroplane, where you first choose a heading (Such as flying south
- * east), then you set the pitch (such as 30 degrees to take off) and
- * then you might set a roll, by dipping the left, wing as you prepare
- * to turn.
- *
- * They have some advantages and limitations that it helps to be
- * aware of:
- *
- * Advantages:
- * <itemizedlist>
- * <listitem>
- * Easy to understand and use, compared to quaternions and matrices,
- * so may be a good choice for a user interface.
- * </listitem>
- * <listitem>
- * Efficient storage, needing only 3 components any rotation can be
- * represented.
- * <note>Actually the #CoglEuler type isn't optimized for size because
- * we may cache the equivalent #CoglQuaternion along with a euler
- * rotation, but it would be trivial for an application to track the
- * components of euler rotations in a packed float array if optimizing
- * for size was important. The values could be passed to Cogl only when
- * manipulation is necessary.</note>
- * </listitem>
- * </itemizedlist>
- *
- * Disadvantages:
- * <itemizedlist>
- * <listitem>
- * Aliasing: it's possible to represent some rotations with multiple
- * different heading, pitch and roll rotations.
- * </listitem>
- * <listitem>
- * They can suffer from a problem called Gimbal Lock. A good
- * explanation of this can be seen on wikipedia here:
- * http://en.wikipedia.org/wiki/Gimbal_lock but basically two
- * of the axis of rotation may become aligned and so you loose a
- * degree of freedom. For example a pitch of +-90° would mean that
- * heading and bank rotate around the same axis.
- * </listitem>
- * <listitem>
- * If you use euler angles to orient something in 3D space and try to
- * transition between orientations by interpolating the component
- * angles you probably wont get the transitions you expect as they may
- * not follow the shortest path between the two orientations.
- * </listitem>
- * <listitem>
- * There's no standard to what order the component axis rotations are
- * applied. The most common convention seems to be what we do in Cogl
- * with heading (y-axis), pitch (x-axis) and then roll (z-axis), but
- * other software might apply x-axis, y-axis then z-axis or any other
- * order so you need to consider this if you are accepting euler
- * rotations from some other software. Other software may also use
- * slightly different aeronautical terms, such as "yaw" instead of
- * "heading" or "bank" instead of "roll".
- * </listitem>
- * </itemizedlist>
- *
- * To minimize the aliasing issue we may refer to "Canonical Euler"
- * angles where heading and roll are restricted to +- 180° and pitch is
- * restricted to +- 90°. If pitch is +- 90° bank is set to 0°.
- *
- * Quaternions don't suffer from Gimbal Lock and they can be nicely
- * interpolated between, their disadvantage is that they don't have an
- * intuitive representation.
- *
- * A common practice is to accept angles in the intuitive Euler form
- * and convert them to quaternions internally to avoid Gimbal Lock and
- * handle interpolations. See cogl_quaternion_init_from_euler().
- */
-
-/**
- * CoglEuler:
- * @heading: Angle to rotate around an object's y axis
- * @pitch: Angle to rotate around an object's x axis
- * @roll: Angle to rotate around an object's z axis
- *
- * Represents an ordered rotation first of @heading degrees around an
- * object's y axis, then @pitch degrees around an object's x axis and
- * finally @roll degrees around an object's z axis.
- *
- * <note>It's important to understand the that axis are associated
- * with the object being rotated, so the axis also rotate in sequence
- * with the rotations being applied.</note>
- *
- * The members of a #CoglEuler can be initialized, for example, with
- * cogl_euler_init() and cogl_euler_init_from_quaternion ().
- *
- * You may also want to look at cogl_quaternion_init_from_euler() if
- * you want to do interpolation between 3d rotations.
- *
- * Since: 2.0
- */
-struct _CoglEuler
-{
-  /*< public > */
-  float heading;
-  float pitch;
-  float roll;
-
-  /*< private > */
-  /* May cached a quaternion here in the future */
-  float padding0;
-  float padding1;
-  float padding2;
-  float padding3;
-  float padding4;
-};
-COGL_STRUCT_SIZE_ASSERT (CoglEuler, 32);
-
-/**
- * cogl_euler_get_gtype:
- *
- * Returns: a #GType that can be used with the GLib type system.
- */
-GType cogl_euler_get_gtype (void);
-
-/**
- * cogl_euler_init:
- * @euler: The #CoglEuler angle to initialize
- * @heading: Angle to rotate around an object's y axis
- * @pitch: Angle to rotate around an object's x axis
- * @roll: Angle to rotate around an object's z axis
- *
- * Initializes @euler to represent a rotation of @x_angle degrees
- * around the x axis, then @y_angle degrees around the y_axis and
- * @z_angle degrees around the z axis.
- *
- * Since: 2.0
- */
-void
-cogl_euler_init (CoglEuler *euler,
-                 float heading,
-                 float pitch,
-                 float roll);
-
-/**
- * cogl_euler_init_from_matrix:
- * @euler: The #CoglEuler angle to initialize
- * @matrix: A #CoglMatrix containing a rotation, but no scaling,
- *          mirroring or skewing.
- *
- * Extracts a euler rotation from the given @matrix and
- * initializses @euler with the component x, y and z rotation angles.
- */
-void
-cogl_euler_init_from_matrix (CoglEuler *euler,
-                             const CoglMatrix *matrix);
-
-/**
- * cogl_euler_init_from_quaternion:
- * @euler: The #CoglEuler angle to initialize
- * @quaternion: A #CoglEuler with the rotation to initialize with
- *
- * Initializes a @euler rotation with the equivalent rotation
- * represented by the given @quaternion.
- */
-void
-cogl_euler_init_from_quaternion (CoglEuler *euler,
-                                 const CoglQuaternion *quaternion);
-
-/**
- * cogl_euler_equal:
- * @v1: The first euler angle to compare
- * @v2: The second euler angle to compare
- *
- * Compares the two given euler angles @v1 and @v1 and it they are
- * equal returns %TRUE else %FALSE.
- *
- * <note>This function only checks that all three components rotations
- * are numerically equal, it does not consider that some rotations
- * can be represented with different component rotations</note>
- *
- * Returns: %TRUE if @v1 and @v2 are equal else %FALSE.
- * Since: 2.0
- */
-gboolean
-cogl_euler_equal (const void *v1, const void *v2);
-
-/**
- * cogl_euler_copy:
- * @src: A #CoglEuler to copy
- *
- * Allocates a new #CoglEuler and initilizes it with the component
- * angles of @src. The newly allocated euler should be freed using
- * cogl_euler_free().
- *
- * Returns: A newly allocated #CoglEuler
- * Since: 2.0
- */
-CoglEuler *
-cogl_euler_copy (const CoglEuler *src);
-
-/**
- * cogl_euler_free:
- * @euler: A #CoglEuler allocated via cogl_euler_copy()
- *
- * Frees a #CoglEuler that was previously allocated using
- * cogl_euler_copy().
- *
- * Since: 2.0
- */
-void
-cogl_euler_free (CoglEuler *euler);
-
-G_END_DECLS
-
-#endif /* __COGL_EULER_H */
-

cogl/cogl/cogl-framebuffer.c

@@ -1603,7 +1603,7 @@ cogl_framebuffer_rotate (CoglFramebuffer *framebuffer,
 
 void
 cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer,
-                                    const CoglQuaternion *quaternion)
+                                    const graphene_quaternion_t *quaternion)
 {
   CoglMatrixStack *modelview_stack =
     _cogl_framebuffer_get_modelview_stack (framebuffer);
@@ -1616,7 +1616,7 @@ cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer,
 
 void
 cogl_framebuffer_rotate_euler (CoglFramebuffer *framebuffer,
-                               const CoglEuler *euler)
+                               const graphene_euler_t *euler)
 {
   CoglMatrixStack *modelview_stack =
     _cogl_framebuffer_get_modelview_stack (framebuffer);

cogl/cogl/cogl-framebuffer.h

@@ -51,11 +51,11 @@ typedef struct _CoglFramebuffer CoglFramebuffer;
 #include <cogl/cogl-pipeline.h>
 #include <cogl/cogl-indices.h>
 #include <cogl/cogl-bitmap.h>
-#include <cogl/cogl-quaternion.h>
-#include <cogl/cogl-euler.h>
 #include <cogl/cogl-texture.h>
 #include <glib-object.h>
 
+#include <graphene.h>
+
 G_BEGIN_DECLS
 
 /**
@@ -364,7 +364,7 @@ cogl_framebuffer_rotate (CoglFramebuffer *framebuffer,
 /**
  * cogl_framebuffer_rotate_quaternion:
  * @framebuffer: A #CoglFramebuffer pointer
- * @quaternion: A #CoglQuaternion
+ * @quaternion: A #graphene_quaternion_t
  *
  * Multiplies the current model-view matrix by one that rotates
  * according to the rotation described by @quaternion.
@@ -374,12 +374,12 @@ cogl_framebuffer_rotate (CoglFramebuffer *framebuffer,
  */
 void
 cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer,
-                                    const CoglQuaternion *quaternion);
+                                    const graphene_quaternion_t *quaternion);
 
 /**
  * cogl_framebuffer_rotate_euler:
  * @framebuffer: A #CoglFramebuffer pointer
- * @euler: A #CoglEuler
+ * @euler: A #graphene_euler_t
  *
  * Multiplies the current model-view matrix by one that rotates
  * according to the rotation described by @euler.
@@ -389,7 +389,7 @@ cogl_framebuffer_rotate_quaternion (CoglFramebuffer *framebuffer,
  */
 void
 cogl_framebuffer_rotate_euler (CoglFramebuffer *framebuffer,
-                               const CoglEuler *euler);
+                               const graphene_euler_t *euler);
 
 /**
  * cogl_framebuffer_transform:

cogl/cogl/cogl-graphene-utils.c

@@ -0,0 +1,75 @@
+/*
+ * Cogl
+ *
+ * A Low Level GPU Graphics and Utilities API
+ *
+ * Copyright (C) 2019 Endless, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *
+ *
+ * Authors:
+ *   Georges Basile Stavracas Neto <gbsneto@gnome.org>
+ */
+
+#include "cogl-graphene-utils.h"
+#include "cogl-matrix-private.h"
+
+#include <stdint.h>
+
+gboolean
+cogl_graphene_matrix_equal (const graphene_matrix_t *matrix_a,
+                            const graphene_matrix_t *matrix_b)
+{
+  graphene_vec4_t row_a, row_b;
+
+#define COMPARE_MATRIX_ROW(row) \
+  G_STMT_START { \
+    graphene_matrix_get_row (matrix_a, row, &row_a); \
+    graphene_matrix_get_row (matrix_b, row, &row_b); \
+    if (!graphene_vec4_equal (&row_a, &row_b)) \
+      return FALSE; \
+  } G_STMT_END
+
+  COMPARE_MATRIX_ROW (0);
+  COMPARE_MATRIX_ROW (1);
+  COMPARE_MATRIX_ROW (2);
+  COMPARE_MATRIX_ROW (3);
+
+#undef COMPARE_MATRIX_ROW
+
+  return TRUE;
+}
+
+void
+cogl_matrix_to_graphene_matrix (const CoglMatrix  *matrix,
+                                graphene_matrix_t *res)
+{
+  graphene_matrix_init_from_float (res, (float *)matrix);
+}
+
+void
+graphene_matrix_to_cogl_matrix (const graphene_matrix_t *matrix,
+                                CoglMatrix              *res)
+{
+  graphene_matrix_to_float (matrix, (float *)res);
+}

cogl/cogl/cogl-graphene-utils.h

@@ -3,7 +3,7 @@
  *
  * A Low Level GPU Graphics and Utilities API
  *
- * Copyright (C) 2008,2009 Intel Corporation.
+ * Copyright (C) 2019 Endless, Inc.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -25,20 +25,30 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ *
+ *
  * Authors:
- *   Robert Bragg <robert@linux.intel.com>
+ *   Georges Basile Stavracas Neto <gbsneto@gnome.org>
  */
 
-#ifndef __COGL_QUATERNION_PRIVATE_H__
-#define __COGL_QUATERNION_PRIVATE_H__
+#ifndef COGL_GRAPHENE_UTILS_H
+#define COGL_GRAPHENE_UTILS_H
 
-#include <glib.h>
+#include "cogl-matrix.h"
 
-/* squared length */
-#define _COGL_QUATERNION_NORM(Q) \
-  ((Q)->x*(Q)->x + (Q)->y*(Q)->y + (Q)->z*(Q)->z + (Q)->w*(Q)->w)
+#include <graphene.h>
+#include <glib-object.h>
 
-#define _COGL_QUATERNION_DEGREES_TO_RADIANS (G_PI / 180.0f)
-#define _COGL_QUATERNION_RADIANS_TO_DEGREES (180.0f / G_PI)
+gboolean
+cogl_graphene_matrix_equal (const graphene_matrix_t *matrix_a,
+                            const graphene_matrix_t *matrix_b);
 
-#endif /* __COGL_QUATERNION_PRIVATE_H__ */
+void
+cogl_matrix_to_graphene_matrix (const CoglMatrix  *matrix,
+                                graphene_matrix_t *res);
+
+void
+graphene_matrix_to_cogl_matrix (const graphene_matrix_t *matrix,
+                                CoglMatrix              *res);
+
+#endif /* COGL_GRAPHENE_UTILS_H */

cogl/cogl/cogl-matrix-stack-private.h

@@ -69,9 +69,7 @@ typedef struct _CoglMatrixEntryTranslate
 {
   CoglMatrixEntry _parent_data;
 
-  float x;
-  float y;
-  float z;
+  graphene_point3d_t t;
 
 } CoglMatrixEntryTranslate;
 
@@ -80,9 +78,7 @@ typedef struct _CoglMatrixEntryRotate
   CoglMatrixEntry _parent_data;
 
   float angle;
-  float x;
-  float y;
-  float z;
+  graphene_vec3_t axis;
 
 } CoglMatrixEntryRotate;
 
@@ -90,20 +86,14 @@ typedef struct _CoglMatrixEntryRotateEuler
 {
   CoglMatrixEntry _parent_data;
 
-  /* This doesn't store an actual CoglEuler in order to avoid the
-   * padding */
-  float heading;
-  float pitch;
-  float roll;
+  graphene_euler_t euler;
 } CoglMatrixEntryRotateEuler;
 
 typedef struct _CoglMatrixEntryRotateQuaternion
 {
   CoglMatrixEntry _parent_data;
 
-  /* This doesn't store an actual CoglQuaternion in order to avoid the
-   * padding */
-  float values[4];
+  graphene_quaternion_t quaternion;
 } CoglMatrixEntryRotateQuaternion;
 
 typedef struct _CoglMatrixEntryScale
@@ -180,13 +170,6 @@ typedef enum
   COGL_MATRIX_TEXTURE
 } CoglMatrixMode;
 
-void
-_cogl_matrix_entry_flush_to_gl_builtins (CoglContext *ctx,
-                                         CoglMatrixEntry *entry,
-                                         CoglMatrixMode mode,
-                                         CoglFramebuffer *framebuffer,
-                                         gboolean disable_flip);
-
 void
 _cogl_matrix_entry_cache_init (CoglMatrixEntryCache *cache);
 

cogl/cogl/cogl-matrix-stack.c

@@ -158,9 +158,7 @@ cogl_matrix_stack_translate (CoglMatrixStack *stack,
 
   entry = _cogl_matrix_stack_push_operation (stack, COGL_MATRIX_OP_TRANSLATE);
 
-  entry->x = x;
-  entry->y = y;
-  entry->z = z;
+  graphene_point3d_init (&entry->t, x, y, z);
 }
 
 void
@@ -175,38 +173,29 @@ cogl_matrix_stack_rotate (CoglMatrixStack *stack,
   entry = _cogl_matrix_stack_push_operation (stack, COGL_MATRIX_OP_ROTATE);
 
   entry->angle = angle;
-  entry->x = x;
-  entry->y = y;
-  entry->z = z;
+  graphene_vec3_init (&entry->axis, x, y, z);
 }
 
 void
 cogl_matrix_stack_rotate_quaternion (CoglMatrixStack *stack,
-                                     const CoglQuaternion *quaternion)
+                                     const graphene_quaternion_t *quaternion)
 {
   CoglMatrixEntryRotateQuaternion *entry;
 
   entry = _cogl_matrix_stack_push_operation (stack,
                                              COGL_MATRIX_OP_ROTATE_QUATERNION);
-
-  entry->values[0] = quaternion->w;
-  entry->values[1] = quaternion->x;
-  entry->values[2] = quaternion->y;
-  entry->values[3] = quaternion->z;
+  graphene_quaternion_init_from_quaternion (&entry->quaternion, quaternion);
 }
 
 void
-cogl_matrix_stack_rotate_euler (CoglMatrixStack *stack,
-                                 const CoglEuler *euler)
+cogl_matrix_stack_rotate_euler (CoglMatrixStack        *stack,
+                                const graphene_euler_t *euler)
 {
   CoglMatrixEntryRotateEuler *entry;
 
   entry = _cogl_matrix_stack_push_operation (stack,
                                              COGL_MATRIX_OP_ROTATE_EULER);
-
-  entry->heading = euler->heading;
-  entry->pitch = euler->pitch;
-  entry->roll = euler->roll;
+  graphene_euler_init_from_euler (&entry->euler, euler);
 }
 
 void
@@ -560,9 +549,9 @@ initialized:
             CoglMatrixEntryTranslate *translate =
               (CoglMatrixEntryTranslate *)children[i];
             cogl_matrix_translate (matrix,
-                                   translate->x,
-                                   translate->y,
-                                   translate->z);
+                                   translate->t.x,
+                                   translate->t.y,
+                                   translate->t.z);
             continue;
           }
         case COGL_MATRIX_OP_ROTATE:
@@ -571,31 +560,24 @@ initialized:
               (CoglMatrixEntryRotate *)children[i];
             cogl_matrix_rotate (matrix,
                                 rotate->angle,
-                                rotate->x,
-                                rotate->y,
-                                rotate->z);
+                                graphene_vec3_get_x (&rotate->axis),
+                                graphene_vec3_get_y (&rotate->axis),
+                                graphene_vec3_get_z (&rotate->axis));
             continue;
           }
         case COGL_MATRIX_OP_ROTATE_EULER:
           {
             CoglMatrixEntryRotateEuler *rotate =
               (CoglMatrixEntryRotateEuler *)children[i];
-            CoglEuler euler;
-            cogl_euler_init (&euler,
-                             rotate->heading,
-                             rotate->pitch,
-                             rotate->roll);
             cogl_matrix_rotate_euler (matrix,
-                                      &euler);
+                                      &rotate->euler);
             continue;
           }
         case COGL_MATRIX_OP_ROTATE_QUATERNION:
           {
             CoglMatrixEntryRotateQuaternion *rotate =
               (CoglMatrixEntryRotateQuaternion *)children[i];
-            CoglQuaternion quaternion;
-            cogl_quaternion_init_from_array (&quaternion, rotate->values);
-            cogl_matrix_rotate_quaternion (matrix, &quaternion);
+            cogl_matrix_rotate_quaternion (matrix, &rotate->quaternion);
             continue;
           }
         case COGL_MATRIX_OP_SCALE:
@@ -790,9 +772,9 @@ cogl_matrix_entry_calculate_translation (CoglMatrixEntry *entry0,
 
       translate = (CoglMatrixEntryTranslate *)node0;
 
-      *x = *x - translate->x;
-      *y = *y - translate->y;
-      *z = *z - translate->z;
+      *x = *x - translate->t.x;
+      *y = *y - translate->t.y;
+      *z = *z - translate->t.z;
     }
   for (head1 = common_ancestor1->next; head1; head1 = head1->next)
     {
@@ -805,9 +787,9 @@ cogl_matrix_entry_calculate_translation (CoglMatrixEntry *entry0,
 
       translate = (CoglMatrixEntryTranslate *)node1;
 
-      *x = *x + translate->x;
-      *y = *y + translate->y;
-      *z = *z + translate->z;
+      *x = *x + translate->t.x;
+      *y = *y + translate->t.y;
+      *z = *z + translate->t.z;
     }
 
   return TRUE;
@@ -819,127 +801,6 @@ cogl_matrix_entry_is_identity (CoglMatrixEntry *entry)
   return entry ? entry->op == COGL_MATRIX_OP_LOAD_IDENTITY : FALSE;
 }
 
-static void
-_cogl_matrix_flush_to_gl_builtin (CoglContext *ctx,
-                                  gboolean is_identity,
-                                  CoglMatrix *matrix,
-                                  CoglMatrixMode mode)
-{
-  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
-
-#ifdef HAVE_COGL_GL
-  if (ctx->flushed_matrix_mode != mode)
-    {
-      GLenum gl_mode = 0;
-
-      switch (mode)
-        {
-        case COGL_MATRIX_MODELVIEW:
-          gl_mode = GL_MODELVIEW;
-          break;
-
-        case COGL_MATRIX_PROJECTION:
-          gl_mode = GL_PROJECTION;
-          break;
-
-        case COGL_MATRIX_TEXTURE:
-          gl_mode = GL_TEXTURE;
-          break;
-        }
-
-      GE (ctx, glMatrixMode (gl_mode));
-      ctx->flushed_matrix_mode = mode;
-    }
-
-  if (is_identity)
-    GE (ctx, glLoadIdentity ());
-  else
-    GE (ctx, glLoadMatrixf (cogl_matrix_get_array (matrix)));
-#endif
-}
-
-void
-_cogl_matrix_entry_flush_to_gl_builtins (CoglContext *ctx,
-                                         CoglMatrixEntry *entry,
-                                         CoglMatrixMode mode,
-                                         CoglFramebuffer *framebuffer,
-                                         gboolean disable_flip)
-{
-  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
-
-#ifdef HAVE_COGL_GL
-  {
-    gboolean needs_flip;
-    CoglMatrixEntryCache *cache;
-
-    if (mode == COGL_MATRIX_PROJECTION)
-      {
-        /* Because Cogl defines texture coordinates to have a top left
-         * origin and because offscreen framebuffers may be used for
-         * rendering to textures we always render upside down to
-         * offscreen buffers. Also for some backends we need to render
-         * onscreen buffers upside-down too.
-         */
-        if (disable_flip)
-          needs_flip = FALSE;
-        else
-          needs_flip = cogl_is_offscreen (framebuffer);
-
-        cache = &ctx->builtin_flushed_projection;
-      }
-    else
-      {
-        needs_flip = FALSE;
-
-        if (mode == COGL_MATRIX_MODELVIEW)
-          cache = &ctx->builtin_flushed_modelview;
-        else
-          cache = NULL;
-      }
-
-    /* We don't need to do anything if the state is the same */
-    if (!cache ||
-        _cogl_matrix_entry_cache_maybe_update (cache, entry, needs_flip))
-      {
-        gboolean is_identity;
-        CoglMatrix matrix;
-
-        if (entry->op == COGL_MATRIX_OP_LOAD_IDENTITY)
-          is_identity = TRUE;
-        else
-          {
-            is_identity = FALSE;
-            cogl_matrix_entry_get (entry, &matrix);
-          }
-
-        if (needs_flip)
-          {
-            CoglMatrix flipped_matrix;
-
-            cogl_matrix_multiply (&flipped_matrix,
-                                  &ctx->y_flip_matrix,
-                                  is_identity ?
-                                  &ctx->identity_matrix :
-                                  &matrix);
-
-            _cogl_matrix_flush_to_gl_builtin (ctx,
-                                              /* not identity */
-                                              FALSE,
-                                              &flipped_matrix,
-                                              mode);
-          }
-        else
-          {
-            _cogl_matrix_flush_to_gl_builtin (ctx,
-                                              is_identity,
-                                              &matrix,
-                                              mode);
-          }
-      }
-  }
-#endif
-}
-
 gboolean
 cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
                          CoglMatrixEntry *entry1)
@@ -970,9 +831,7 @@ cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
             /* We could perhaps use an epsilon to compare here?
              * I expect the false negatives are probaly never going to
              * be a problem and this is a bit cheaper. */
-            if (translate0->x != translate1->x ||
-                translate0->y != translate1->y ||
-                translate0->z != translate1->z)
+            if (!graphene_point3d_equal (&translate0->t, &translate1->t))
               return FALSE;
           }
           break;
@@ -983,9 +842,7 @@ cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
             CoglMatrixEntryRotate *rotate1 =
               (CoglMatrixEntryRotate *)entry1;
             if (rotate0->angle != rotate1->angle ||
-                rotate0->x != rotate1->x ||
-                rotate0->y != rotate1->y ||
-                rotate0->z != rotate1->z)
+                !graphene_vec3_equal (&rotate0->axis, &rotate1->axis))
               return FALSE;
           }
           break;
@@ -995,10 +852,9 @@ cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
               (CoglMatrixEntryRotateQuaternion *)entry0;
             CoglMatrixEntryRotateQuaternion *rotate1 =
               (CoglMatrixEntryRotateQuaternion *)entry1;
-            int i;
-            for (i = 0; i < 4; i++)
-              if (rotate0->values[i] != rotate1->values[i])
-                return FALSE;
+            if (!graphene_quaternion_equal (&rotate0->quaternion,
+                                            &rotate1->quaternion))
+              return FALSE;
           }
           break;
         case COGL_MATRIX_OP_ROTATE_EULER:
@@ -1008,9 +864,7 @@ cogl_matrix_entry_equal (CoglMatrixEntry *entry0,
             CoglMatrixEntryRotateEuler *rotate1 =
               (CoglMatrixEntryRotateEuler *)entry1;
 
-            if (rotate0->heading != rotate1->heading ||
-                rotate0->pitch != rotate1->pitch ||
-                rotate0->roll != rotate1->roll)
+            if (!graphene_euler_equal (&rotate0->euler, &rotate1->euler))
               return FALSE;
           }
           break;
@@ -1086,9 +940,9 @@ cogl_debug_matrix_entry_print (CoglMatrixEntry *entry)
             CoglMatrixEntryTranslate *translate =
               (CoglMatrixEntryTranslate *)entry;
             g_print ("  TRANSLATE X=%f Y=%f Z=%f\n",
-                     translate->x,
-                     translate->y,
-                     translate->z);
+                     translate->t.x,
+                     translate->t.y,
+                     translate->t.z);
             continue;
           }
         case COGL_MATRIX_OP_ROTATE:
@@ -1097,20 +951,22 @@ cogl_debug_matrix_entry_print (CoglMatrixEntry *entry)
               (CoglMatrixEntryRotate *)entry;
             g_print ("  ROTATE ANGLE=%f X=%f Y=%f Z=%f\n",
                      rotate->angle,
-                     rotate->x,
-                     rotate->y,
-                     rotate->z);
+                     graphene_vec3_get_x (&rotate->axis),
+                     graphene_vec3_get_y (&rotate->axis),
+                     graphene_vec3_get_z (&rotate->axis));
             continue;
           }
         case COGL_MATRIX_OP_ROTATE_QUATERNION:
           {
             CoglMatrixEntryRotateQuaternion *rotate =
               (CoglMatrixEntryRotateQuaternion *)entry;
+            graphene_vec4_t v;
+            graphene_quaternion_to_vec4 (&rotate->quaternion, &v);
             g_print ("  ROTATE QUATERNION w=%f x=%f y=%f z=%f\n",
-                     rotate->values[0],
-                     rotate->values[1],
-                     rotate->values[2],
-                     rotate->values[3]);
+                     graphene_vec4_get_w (&v),
+                     graphene_vec4_get_x (&v),
+                     graphene_vec4_get_y (&v),
+                     graphene_vec4_get_z (&v));
             continue;
           }
         case COGL_MATRIX_OP_ROTATE_EULER:
@@ -1118,9 +974,9 @@ cogl_debug_matrix_entry_print (CoglMatrixEntry *entry)
             CoglMatrixEntryRotateEuler *rotate =
               (CoglMatrixEntryRotateEuler *)entry;
             g_print ("  ROTATE EULER heading=%f pitch=%f roll=%f\n",
-                     rotate->heading,
-                     rotate->pitch,
-                     rotate->roll);
+                     graphene_euler_get_y (&rotate->euler),
+                     graphene_euler_get_x (&rotate->euler),
+                     graphene_euler_get_z (&rotate->euler));
             continue;
           }
         case COGL_MATRIX_OP_SCALE:

cogl/cogl/cogl-matrix-stack.h

@@ -42,6 +42,7 @@
 #include "cogl-matrix.h"
 #include "cogl-context.h"
 
+#include <graphene.h>
 
 /**
  * SECTION:cogl-matrix-stack
@@ -309,26 +310,26 @@ cogl_matrix_stack_rotate (CoglMatrixStack *stack,
 /**
  * cogl_matrix_stack_rotate_quaternion:
  * @stack: A #CoglMatrixStack
- * @quaternion: A #CoglQuaternion
+ * @quaternion: A #graphene_quaternion_t
  *
  * Multiplies the current matrix by one that rotates according to the
  * rotation described by @quaternion.
  */
 void
 cogl_matrix_stack_rotate_quaternion (CoglMatrixStack *stack,
-                                     const CoglQuaternion *quaternion);
+                                     const graphene_quaternion_t *quaternion);
 
 /**
  * cogl_matrix_stack_rotate_euler:
  * @stack: A #CoglMatrixStack
- * @euler: A #CoglEuler
+ * @euler: A #graphene_euler_t
  *
  * Multiplies the current matrix by one that rotates according to the
  * rotation described by @euler.
  */
 void
 cogl_matrix_stack_rotate_euler (CoglMatrixStack *stack,
-                                const CoglEuler *euler);
+                                const graphene_euler_t *euler);
 
 /**
  * cogl_matrix_stack_multiply:

cogl/cogl/cogl-matrix.h

@@ -41,9 +41,10 @@
 #include <cogl/cogl-types.h>
 #include <cogl/cogl-macros.h>
 
-#include <cogl/cogl-quaternion.h>
 #include <glib-object.h>
 
+#include <graphene.h>
+
 G_BEGIN_DECLS
 
 /**
@@ -59,7 +60,7 @@ G_BEGIN_DECLS
  * CoglMatrix:
  *
  * A CoglMatrix holds a 4x4 transform matrix. This is a single precision,
- * column-major matrix which means it is compatible with what OpenGL expects.
+ * row-major matrix.
  *
  * A CoglMatrix can represent transforms such as, rotations, scaling,
  * translation, sheering, and linear projections. You can combine these
@@ -85,40 +86,31 @@ G_BEGIN_DECLS
  */
 struct _CoglMatrix
 {
-  /* column 0 */
+  /* row 0 */
   float xx;
-  float yx;
-  float zx;
-  float wx;
-
-  /* column 1 */
   float xy;
-  float yy;
-  float zy;
-  float wy;
-
-  /* column 2 */
   float xz;
-  float yz;
-  float zz;
-  float wz;
-
-  /* column 3 */
   float xw;
+
+  /* row 1 */
+  float yx;
+  float yy;
+  float yz;
   float yw;
+
+  /* row 2 */
+  float zx;
+  float zy;
+  float zz;
   float zw;
+
+  /* row 3 */
+  float wx;
+  float wy;
+  float wz;
   float ww;
-
-  /*< private >*/
-
-  /* Note: we may want to extend this later with private flags
-   * and a cache of the inverse transform matrix. */
-  float          COGL_PRIVATE (inv)[16];
-  unsigned long  COGL_PRIVATE (type);
-  unsigned long  COGL_PRIVATE (flags);
-  unsigned long  COGL_PRIVATE (_padding3);
 };
-COGL_STRUCT_SIZE_ASSERT (CoglMatrix, 128 + sizeof (unsigned long) * 3);
+COGL_STRUCT_SIZE_ASSERT (CoglMatrix, 64);
 
 
 /**
@@ -147,10 +139,10 @@ cogl_matrix_init_identity (CoglMatrix *matrix);
  * Resets matrix to the (tx, ty, tz) translation matrix:
  *
  * |[
- *   .xx=1; .xy=0; .xz=0; .xw=tx;
- *   .yx=0; .yy=1; .yz=0; .yw=ty;
- *   .zx=0; .zy=0; .zz=1; .zw=tz;
- *   .wx=0; .wy=0; .wz=0; .ww=1;
+ *   .xx=1; .xy=0; .xz=0; .xw=0;
+ *   .yx=0; .yy=1; .yz=0; .yw=0;
+ *   .zx=0; .zy=0; .zz=1; .zw=0;
+ *   .wx=tx; .wy=ty; .wz=tz; .ww=1;
  * ]|
  *
  * Since: 2.0
@@ -202,13 +194,13 @@ cogl_matrix_rotate (CoglMatrix *matrix,
  * @quaternion: A quaternion describing a rotation
  *
  * Multiplies @matrix with a rotation transformation described by the
- * given #CoglQuaternion.
+ * given #graphene_quaternion_t.
  *
  * Since: 2.0
  */
 void
 cogl_matrix_rotate_quaternion (CoglMatrix *matrix,
-                               const CoglQuaternion *quaternion);
+                               const graphene_quaternion_t *quaternion);
 
 /**
  * cogl_matrix_rotate_euler:
@@ -216,13 +208,13 @@ cogl_matrix_rotate_quaternion (CoglMatrix *matrix,
  * @euler: A euler describing a rotation
  *
  * Multiplies @matrix with a rotation transformation described by the
- * given #CoglEuler.
+ * given #graphene_euler_t.
  *
  * Since: 2.0
  */
 void
 cogl_matrix_rotate_euler (CoglMatrix *matrix,
-                          const CoglEuler *euler);
+                          const graphene_euler_t *euler);
 
 /**
  * cogl_matrix_translate:
@@ -387,34 +379,6 @@ cogl_matrix_orthographic (CoglMatrix *matrix,
                           float near,
                           float far);
 
-/**
- * cogl_matrix_ortho:
- * @matrix: A 4x4 transformation matrix
- * @left: The coordinate for the left clipping plane
- * @right: The coordinate for the right clipping plane
- * @bottom: The coordinate for the bottom clipping plane
- * @top: The coordinate for the top clipping plane
- * @near: The <emphasis>distance</emphasis> to the near clipping
- *   plane (will be <emphasis>negative</emphasis> if the plane is
- *   behind the viewer)
- * @far: The <emphasis>distance</emphasis> to the far clipping
- *   plane (will be <emphasis>negative</emphasis> if the plane is
- *   behind the viewer)
- *
- * Multiplies @matrix by a parallel projection matrix.
- *
- * Deprecated: 1.10: Use cogl_matrix_orthographic()
- */
-COGL_DEPRECATED_FOR (cogl_matrix_orthographic)
-void
-cogl_matrix_ortho (CoglMatrix *matrix,
-                   float       left,
-                   float       right,
-                   float       bottom,
-                   float       top,
-                   float       near,
-                   float       far);
-
 /**
  * cogl_matrix_view_2d_in_frustum:
  * @matrix: A 4x4 transformation matrix
@@ -507,35 +471,35 @@ cogl_matrix_init_from_array (CoglMatrix *matrix,
 /**
  * cogl_matrix_get_array:
  * @matrix: A 4x4 transformation matrix
+ * @array: the array to copy the contents of @matrix to.
  *
  * Casts @matrix to a float array which can be directly passed to OpenGL.
- *
- * Return value: a pointer to the float array
  */
-const float *
-cogl_matrix_get_array (const CoglMatrix *matrix);
+void
+cogl_matrix_get_array (const CoglMatrix *matrix,
+                       float *array);
 
 /**
  * cogl_matrix_init_from_quaternion:
  * @matrix: A 4x4 transformation matrix
- * @quaternion: A #CoglQuaternion
+ * @quaternion: A #graphene_quaternion_t
  *
- * Initializes @matrix from a #CoglQuaternion rotation.
+ * Initializes @matrix from a #graphene_quaternion_t rotation.
  */
 void
 cogl_matrix_init_from_quaternion (CoglMatrix *matrix,
-                                  const CoglQuaternion *quaternion);
+                                  const graphene_quaternion_t *quaternion);
 
 /**
  * cogl_matrix_init_from_euler:
  * @matrix: A 4x4 transformation matrix
- * @euler: A #CoglEuler
+ * @euler: A #graphene_euler_t
  *
- * Initializes @matrix from a #CoglEuler rotation.
+ * Initializes @matrix from a #graphene_euler_t rotation.
  */
 void
 cogl_matrix_init_from_euler (CoglMatrix *matrix,
-                             const CoglEuler *euler);
+                             const graphene_euler_t *euler);
 
 /**
  * cogl_matrix_equal:

cogl/cogl/cogl-pipeline-private.h

@@ -83,7 +83,6 @@ typedef enum
   COGL_PIPELINE_STATE_BLEND_INDEX,
   COGL_PIPELINE_STATE_USER_SHADER_INDEX,
   COGL_PIPELINE_STATE_DEPTH_INDEX,
-  COGL_PIPELINE_STATE_FOG_INDEX,
   COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX,
@@ -132,8 +131,6 @@ typedef enum _CoglPipelineState
     1L<<COGL_PIPELINE_STATE_USER_SHADER_INDEX,
   COGL_PIPELINE_STATE_DEPTH =
     1L<<COGL_PIPELINE_STATE_DEPTH_INDEX,
-  COGL_PIPELINE_STATE_FOG =
-    1L<<COGL_PIPELINE_STATE_FOG_INDEX,
   COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE =
     1L<<COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_POINT_SIZE =
@@ -184,7 +181,6 @@ typedef enum _CoglPipelineState
    COGL_PIPELINE_STATE_BLEND | \
    COGL_PIPELINE_STATE_USER_SHADER | \
    COGL_PIPELINE_STATE_DEPTH | \
-   COGL_PIPELINE_STATE_FOG | \
    COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE | \
    COGL_PIPELINE_STATE_POINT_SIZE | \
    COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE | \
@@ -199,7 +195,6 @@ typedef enum _CoglPipelineState
    COGL_PIPELINE_STATE_LIGHTING | \
    COGL_PIPELINE_STATE_BLEND | \
    COGL_PIPELINE_STATE_DEPTH | \
-   COGL_PIPELINE_STATE_FOG | \
    COGL_PIPELINE_STATE_LOGIC_OPS | \
    COGL_PIPELINE_STATE_CULL_FACE | \
    COGL_PIPELINE_STATE_UNIFORMS | \
@@ -255,16 +250,6 @@ typedef struct
   GLint     blend_dst_factor_rgb;
 } CoglPipelineBlendState;
 
-typedef struct
-{
-  gboolean        enabled;
-  CoglColor       color;
-  CoglFogMode     mode;
-  float           density;
-  float           z_near;
-  float           z_far;
-} CoglPipelineFogState;
-
 typedef struct
 {
   CoglColorMask color_mask;
@@ -297,7 +282,6 @@ typedef struct
   CoglPipelineBlendState blend_state;
   CoglHandle user_program;
   CoglDepthState depth_state;
-  CoglPipelineFogState fog_state;
   float point_size;
   unsigned int non_zero_point_size : 1;
   unsigned int per_vertex_point_size : 1;
@@ -868,9 +852,6 @@ void
 _cogl_pipeline_set_blend_enabled (CoglPipeline *pipeline,
                                   CoglPipelineBlendEnable enable);
 
-gboolean
-_cogl_pipeline_get_fog_enabled (CoglPipeline *pipeline);
-
 #ifdef COGL_DEBUG_ENABLED
 void
 _cogl_pipeline_set_static_breadcrumb (CoglPipeline *pipeline,

cogl/cogl/cogl-pipeline-state-private.h

@@ -49,10 +49,6 @@ _cogl_pipeline_has_non_layer_vertex_snippets (CoglPipeline *pipeline);
 gboolean
 _cogl_pipeline_has_non_layer_fragment_snippets (CoglPipeline *pipeline);
 
-void
-_cogl_pipeline_set_fog_state (CoglPipeline *pipeline,
-                              const CoglPipelineFogState *fog_state);
-
 gboolean
 _cogl_pipeline_color_equal (CoglPipeline *authority0,
                             CoglPipeline *authority1);
@@ -77,10 +73,6 @@ gboolean
 _cogl_pipeline_depth_state_equal (CoglPipeline *authority0,
                                   CoglPipeline *authority1);
 
-gboolean
-_cogl_pipeline_fog_state_equal (CoglPipeline *authority0,
-                                CoglPipeline *authority1);
-
 gboolean
 _cogl_pipeline_non_zero_point_size_equal (CoglPipeline *authority0,
                                           CoglPipeline *authority1);
@@ -152,10 +144,6 @@ void
 _cogl_pipeline_hash_depth_state (CoglPipeline *authority,
                                  CoglPipelineHashState *state);
 
-void
-_cogl_pipeline_hash_fog_state (CoglPipeline *authority,
-                               CoglPipelineHashState *state);
-
 void
 _cogl_pipeline_hash_non_zero_point_size_state (CoglPipeline *authority,
                                                CoglPipelineHashState *state);

cogl/cogl/cogl-pipeline-state.c

@@ -177,24 +177,6 @@ _cogl_pipeline_depth_state_equal (CoglPipeline *authority0,
     }
 }
 
-gboolean
-_cogl_pipeline_fog_state_equal (CoglPipeline *authority0,
-                                CoglPipeline *authority1)
-{
-  CoglPipelineFogState *fog_state0 = &authority0->big_state->fog_state;
-  CoglPipelineFogState *fog_state1 = &authority1->big_state->fog_state;
-
-  if (fog_state0->enabled == fog_state1->enabled &&
-      cogl_color_equal (&fog_state0->color, &fog_state1->color) &&
-      fog_state0->mode == fog_state1->mode &&
-      fog_state0->density == fog_state1->density &&
-      fog_state0->z_near == fog_state1->z_near &&
-      fog_state0->z_far == fog_state1->z_far)
-    return TRUE;
-  else
-    return FALSE;
-}
-
 gboolean
 _cogl_pipeline_non_zero_point_size_equal (CoglPipeline *authority0,
                                           CoglPipeline *authority1)
@@ -1246,41 +1228,6 @@ cogl_pipeline_set_color_mask (CoglPipeline *pipeline,
                                    _cogl_pipeline_logic_ops_state_equal);
 }
 
-void
-_cogl_pipeline_set_fog_state (CoglPipeline *pipeline,
-                              const CoglPipelineFogState *fog_state)
-{
-  CoglPipelineState state = COGL_PIPELINE_STATE_FOG;
-  CoglPipeline *authority;
-  CoglPipelineFogState *current_fog_state;
-
-  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
-
-  authority = _cogl_pipeline_get_authority (pipeline, state);
-
-  current_fog_state = &authority->big_state->fog_state;
-
-  if (current_fog_state->enabled == fog_state->enabled &&
-      cogl_color_equal (&current_fog_state->color, &fog_state->color) &&
-      current_fog_state->mode == fog_state->mode &&
-      current_fog_state->density == fog_state->density &&
-      current_fog_state->z_near == fog_state->z_near &&
-      current_fog_state->z_far == fog_state->z_far)
-    return;
-
-  /* - Flush journal primitives referencing the current state.
-   * - Make sure the pipeline has no dependants so it may be modified.
-   * - If the pipeline isn't currently an authority for the state being
-   *   changed, then initialize that state from the current authority.
-   */
-  _cogl_pipeline_pre_change_notify (pipeline, state, NULL, FALSE);
-
-  pipeline->big_state->fog_state = *fog_state;
-
-  _cogl_pipeline_update_authority (pipeline, authority, state,
-                                   _cogl_pipeline_fog_state_equal);
-}
-
 void
 cogl_pipeline_set_cull_face_mode (CoglPipeline *pipeline,
                                   CoglPipelineCullFaceMode cull_face_mode)
@@ -1904,23 +1851,6 @@ _cogl_pipeline_hash_depth_state (CoglPipeline *authority,
   state->hash = hash;
 }
 
-void
-_cogl_pipeline_hash_fog_state (CoglPipeline *authority,
-                               CoglPipelineHashState *state)
-{
-  CoglPipelineFogState *fog_state = &authority->big_state->fog_state;
-  unsigned long hash = state->hash;
-
-  if (!fog_state->enabled)
-    hash = _cogl_util_one_at_a_time_hash (hash, &fog_state->enabled,
-                                          sizeof (fog_state->enabled));
-  else
-    hash = _cogl_util_one_at_a_time_hash (hash, &fog_state,
-                                          sizeof (CoglPipelineFogState));
-
-  state->hash = hash;
-}
-
 void
 _cogl_pipeline_hash_non_zero_point_size_state (CoglPipeline *authority,
                                                CoglPipelineHashState *state)

cogl/cogl/cogl-pipeline.c

@@ -1014,13 +1014,6 @@ _cogl_pipeline_copy_differences (CoglPipeline *dest,
               sizeof (CoglDepthState));
     }
 
-  if (differences & COGL_PIPELINE_STATE_FOG)
-    {
-      memcpy (&big_state->fog_state,
-              &src->big_state->fog_state,
-              sizeof (CoglPipelineFogState));
-    }
-
   if (differences & COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE)
     big_state->non_zero_point_size = src->big_state->non_zero_point_size;
 
@@ -1143,13 +1136,6 @@ _cogl_pipeline_init_multi_property_sparse_state (CoglPipeline *pipeline,
                 sizeof (CoglDepthState));
         break;
       }
-    case COGL_PIPELINE_STATE_FOG:
-      {
-        memcpy (&pipeline->big_state->fog_state,
-                &authority->big_state->fog_state,
-                sizeof (CoglPipelineFogState));
-        break;
-      }
     case COGL_PIPELINE_STATE_LOGIC_OPS:
       {
         memcpy (&pipeline->big_state->logic_ops_state,
@@ -2298,11 +2284,6 @@ _cogl_pipeline_equal (CoglPipeline *pipeline0,
                                                  authorities1[bit]))
             goto done;
           break;
-        case COGL_PIPELINE_STATE_FOG_INDEX:
-          if (!_cogl_pipeline_fog_state_equal (authorities0[bit],
-                                               authorities1[bit]))
-            goto done;
-          break;
         case COGL_PIPELINE_STATE_CULL_FACE_INDEX:
           if (!_cogl_pipeline_cull_face_state_equal (authorities0[bit],
                                                      authorities1[bit]))
@@ -2441,18 +2422,6 @@ _cogl_pipeline_update_authority (CoglPipeline *pipeline,
     }
 }
 
-gboolean
-_cogl_pipeline_get_fog_enabled (CoglPipeline *pipeline)
-{
-  CoglPipeline *authority;
-
-  _COGL_RETURN_VAL_IF_FAIL (cogl_is_pipeline (pipeline), FALSE);
-
-  authority =
-    _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_FOG);
-  return authority->big_state->fog_state.enabled;
-}
-
 unsigned long
 _cogl_pipeline_get_age (CoglPipeline *pipeline)
 {
@@ -2614,9 +2583,6 @@ _cogl_pipeline_apply_legacy_state (CoglPipeline *pipeline)
       cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
     }
 
-  if (ctx->legacy_fog_state.enabled)
-    _cogl_pipeline_set_fog_state (pipeline, &ctx->legacy_fog_state);
-
   if (ctx->legacy_backface_culling_enabled)
     cogl_pipeline_set_cull_face_mode (pipeline,
                                       COGL_PIPELINE_CULL_FACE_MODE_BACK);
@@ -2766,8 +2732,6 @@ _cogl_pipeline_init_state_hash_functions (void)
     _cogl_pipeline_hash_user_shader_state;
   state_hash_functions[COGL_PIPELINE_STATE_DEPTH_INDEX] =
     _cogl_pipeline_hash_depth_state;
-  state_hash_functions[COGL_PIPELINE_STATE_FOG_INDEX] =
-    _cogl_pipeline_hash_fog_state;
   state_hash_functions[COGL_PIPELINE_STATE_CULL_FACE_INDEX] =
     _cogl_pipeline_hash_cull_face_state;
   state_hash_functions[COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX] =
@@ -2787,7 +2751,7 @@ _cogl_pipeline_init_state_hash_functions (void)
 
   {
   /* So we get a big error if we forget to update this code! */
-  _COGL_STATIC_ASSERT (COGL_PIPELINE_STATE_SPARSE_COUNT == 18,
+  _COGL_STATIC_ASSERT (COGL_PIPELINE_STATE_SPARSE_COUNT == 17,
                        "Make sure to install a hash function for "
                        "newly added pipeline state and update assert "
                        "in _cogl_pipeline_init_state_hash_functions");

cogl/cogl/cogl-quaternion.c

@@ -1,671 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- *
- * Various references relating to quaternions:
- *
- * http://www.cs.caltech.edu/courses/cs171/quatut.pdf
- * http://mathworld.wolfram.com/Quaternion.html
- * http://www.gamedev.net/reference/articles/article1095.asp
- * http://www.cprogramming.com/tutorial/3d/quaternions.html
- * http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm
- * http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56
- * 3D Maths Primer for Graphics and Game Development ISBN-10: 1556229119
- */
-
-#include "cogl-config.h"
-
-#include <cogl-util.h>
-#include <cogl-quaternion.h>
-#include <cogl-quaternion-private.h>
-#include <cogl-matrix.h>
-#include <cogl-vector.h>
-#include <cogl-euler.h>
-#include "cogl-gtype-private.h"
-
-#include <string.h>
-#include <math.h>
-
-#define FLOAT_EPSILON 1e-03
-
-COGL_GTYPE_DEFINE_BOXED (Quaternion, quaternion,
-                         cogl_quaternion_copy,
-                         cogl_quaternion_free);
-
-static CoglQuaternion zero_quaternion =
-{
-  0.0,  0.0, 0.0, 0.0,
-};
-
-static CoglQuaternion identity_quaternion =
-{
-  1.0,  0.0, 0.0, 0.0,
-};
-
-/* This function is just here to be called from GDB so we don't really
-   want to put a declaration in a header and we just add it here to
-   avoid a warning */
-void
-_cogl_quaternion_print (CoglQuaternion *quarternion);
-
-void
-_cogl_quaternion_print (CoglQuaternion *quaternion)
-{
-  g_print ("[ %6.4f (%6.4f, %6.4f, %6.4f)]\n",
-           quaternion->w,
-           quaternion->x,
-           quaternion->y,
-           quaternion->z);
-}
-
-void
-cogl_quaternion_init (CoglQuaternion *quaternion,
-                      float angle,
-                      float x,
-                      float y,
-                      float z)
-{
-  float axis[3] = { x, y, z};
-  cogl_quaternion_init_from_angle_vector (quaternion, angle, axis);
-}
-
-void
-cogl_quaternion_init_from_angle_vector (CoglQuaternion *quaternion,
-                                        float angle,
-                                        const float *axis3f_in)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-  float axis[3];
-  float half_angle;
-  float sin_half_angle;
-
-  /* XXX: Should we make cogl_vector3_normalize have separate in and
-   * out args? */
-  axis[0] = axis3f_in[0];
-  axis[1] = axis3f_in[1];
-  axis[2] = axis3f_in[2];
-  cogl_vector3_normalize (axis);
-
-  half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f;
-  sin_half_angle = sinf (half_angle);
-
-  quaternion->w = cosf (half_angle);
-
-  quaternion->x = axis[0] * sin_half_angle;
-  quaternion->y = axis[1] * sin_half_angle;
-  quaternion->z = axis[2] * sin_half_angle;
-
-  cogl_quaternion_normalize (quaternion);
-}
-
-void
-cogl_quaternion_init_identity (CoglQuaternion *quaternion)
-{
-  quaternion->w = 1.0;
-
-  quaternion->x = 0.0;
-  quaternion->y = 0.0;
-  quaternion->z = 0.0;
-}
-
-void
-cogl_quaternion_init_from_array (CoglQuaternion *quaternion,
-                                 const float *array)
-{
-  quaternion->w = array[0];
-  quaternion->x = array[1];
-  quaternion->y = array[2];
-  quaternion->z = array[3];
-}
-
-void
-cogl_quaternion_init_from_x_rotation (CoglQuaternion *quaternion,
-                                      float angle)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-  float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f;
-
-  quaternion->w = cosf (half_angle);
-
-  quaternion->x = sinf (half_angle);
-  quaternion->y = 0.0f;
-  quaternion->z = 0.0f;
-}
-
-void
-cogl_quaternion_init_from_y_rotation (CoglQuaternion *quaternion,
-                                      float angle)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-  float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f;
-
-  quaternion->w = cosf (half_angle);
-
-  quaternion->x = 0.0f;
-  quaternion->y = sinf (half_angle);
-  quaternion->z = 0.0f;
-}
-
-void
-cogl_quaternion_init_from_z_rotation (CoglQuaternion *quaternion,
-                                      float angle)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-  float half_angle = angle * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f;
-
-  quaternion->w = cosf (half_angle);
-
-  quaternion->x = 0.0f;
-  quaternion->y = 0.0f;
-  quaternion->z = sinf (half_angle);
-}
-
-void
-cogl_quaternion_init_from_euler (CoglQuaternion *quaternion,
-                                 const CoglEuler *euler)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-  float sin_heading =
-    sinf (euler->heading * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-  float sin_pitch =
-    sinf (euler->pitch * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-  float sin_roll =
-    sinf (euler->roll * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-  float cos_heading =
-    cosf (euler->heading * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-  float cos_pitch =
-    cosf (euler->pitch * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-  float cos_roll =
-    cosf (euler->roll * _COGL_QUATERNION_DEGREES_TO_RADIANS * 0.5f);
-
-  quaternion->w =
-    cos_heading * cos_pitch * cos_roll +
-    sin_heading * sin_pitch * sin_roll;
-
-  quaternion->x =
-    cos_heading * sin_pitch * cos_roll +
-    sin_heading * cos_pitch * sin_roll;
-  quaternion->y =
-    sin_heading * cos_pitch * cos_roll -
-    cos_heading * sin_pitch * sin_roll;
-  quaternion->z =
-    cos_heading * cos_pitch * sin_roll -
-    sin_heading * sin_pitch * cos_roll;
-}
-
-void
-cogl_quaternion_init_from_quaternion (CoglQuaternion *quaternion,
-                                      CoglQuaternion *src)
-{
-  memcpy (quaternion, src, sizeof (float) * 4);
-}
-
-/* XXX: it could be nice to make something like this public... */
-/*
- * COGL_MATRIX_READ:
- * @MATRIX: A 4x4 transformation matrix
- * @ROW: The row of the value you want to read
- * @COLUMN: The column of the value you want to read
- *
- * Reads a value from the given matrix using integers to index
- * into the matrix.
- */
-#define COGL_MATRIX_READ(MATRIX, ROW, COLUMN) \
-  (((const float *)matrix)[COLUMN * 4 + ROW])
-
-void
-cogl_quaternion_init_from_matrix (CoglQuaternion *quaternion,
-                                  const CoglMatrix *matrix)
-{
-  /* Algorithm devised by Ken Shoemake, Ref:
-   * http://campar.in.tum.de/twiki/pub/Chair/DwarfTutorial/quatut.pdf
-   */
-
-  /* 3D maths literature refers to the diagonal of a matrix as the
-   * "trace" of a matrix... */
-  float trace = matrix->xx + matrix->yy + matrix->zz;
-  float root;
-
-  if (trace > 0.0f)
-    {
-      root = sqrtf (trace + 1);
-      quaternion->w = root * 0.5f;
-      root = 0.5f / root;
-      quaternion->x = (matrix->zy - matrix->yz) * root;
-      quaternion->y = (matrix->xz - matrix->zx) * root;
-      quaternion->z = (matrix->yx - matrix->xy) * root;
-    }
-  else
-    {
-#define X 0
-#define Y 1
-#define Z 2
-#define W 3
-      int h = X;
-      if (matrix->yy > matrix->xx)
-        h = Y;
-      if (matrix->zz > COGL_MATRIX_READ (matrix, h, h))
-        h = Z;
-      switch (h)
-        {
-#define CASE_MACRO(i, j, k, I, J, K) \
-        case I: \
-          root = sqrtf ((COGL_MATRIX_READ (matrix, I, I) - \
-                         (COGL_MATRIX_READ (matrix, J, J) + \
-                          COGL_MATRIX_READ (matrix, K, K))) + \
-                        COGL_MATRIX_READ (matrix, W, W)); \
-          quaternion->i = root * 0.5f;\
-          root = 0.5f / root;\
-          quaternion->j = (COGL_MATRIX_READ (matrix, I, J) + \
-                           COGL_MATRIX_READ (matrix, J, I)) * root; \
-          quaternion->k = (COGL_MATRIX_READ (matrix, K, I) + \
-                           COGL_MATRIX_READ (matrix, I, K)) * root; \
-          quaternion->w = (COGL_MATRIX_READ (matrix, K, J) - \
-                           COGL_MATRIX_READ (matrix, J, K)) * root;\
-          break
-          CASE_MACRO (x, y, z, X, Y, Z);
-          CASE_MACRO (y, z, x, Y, Z, X);
-          CASE_MACRO (z, x, y, Z, X, Y);
-#undef CASE_MACRO
-#undef X
-#undef Y
-#undef Z
-        }
-    }
-
-  if (matrix->ww != 1.0f)
-    {
-      float s = 1.0 / sqrtf (matrix->ww);
-      quaternion->w *= s;
-      quaternion->x *= s;
-      quaternion->y *= s;
-      quaternion->z *= s;
-    }
-}
-
-gboolean
-cogl_quaternion_equal (const void *v1, const void *v2)
-{
-  const CoglQuaternion *a = v1;
-  const CoglQuaternion *b = v2;
-
-  _COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
-  _COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
-
-  if (v1 == v2)
-    return TRUE;
-
-  return (a->w == b->w &&
-          a->x == b->x &&
-          a->y == b->y &&
-          a->z == b->z);
-}
-
-CoglQuaternion *
-cogl_quaternion_copy (const CoglQuaternion *src)
-{
-  if (G_LIKELY (src))
-    {
-      CoglQuaternion *new = g_slice_new (CoglQuaternion);
-      memcpy (new, src, sizeof (float) * 4);
-      return new;
-    }
-  else
-    return NULL;
-}
-
-void
-cogl_quaternion_free (CoglQuaternion *quaternion)
-{
-  g_slice_free (CoglQuaternion, quaternion);
-}
-
-float
-cogl_quaternion_get_rotation_angle (const CoglQuaternion *quaternion)
-{
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-
-  /* FIXME: clamp [-1, 1] */
-  return 2.0f * acosf (quaternion->w) * _COGL_QUATERNION_RADIANS_TO_DEGREES;
-}
-
-void
-cogl_quaternion_get_rotation_axis (const CoglQuaternion *quaternion,
-                                   float *vector3)
-{
-  float sin_half_angle_sqr;
-  float one_over_sin_angle_over_2;
-
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-
-  /* NB: sin²(𝜃) + cos²(𝜃) = 1 */
-
-  sin_half_angle_sqr = 1.0f - quaternion->w * quaternion->w;
-
-  if (sin_half_angle_sqr <= 0.0f)
-    {
-      /* Either an identity quaternion or numerical imprecision.
-       * Either way we return an arbitrary vector. */
-      vector3[0] = 1;
-      vector3[1] = 0;
-      vector3[2] = 0;
-      return;
-    }
-
-  /* Calculate 1 / sin(𝜃/2) */
-  one_over_sin_angle_over_2 = 1.0f / sqrtf (sin_half_angle_sqr);
-
-  vector3[0] = quaternion->x * one_over_sin_angle_over_2;
-  vector3[1] = quaternion->y * one_over_sin_angle_over_2;
-  vector3[2] = quaternion->z * one_over_sin_angle_over_2;
-}
-
-void
-cogl_quaternion_normalize (CoglQuaternion *quaternion)
-{
-  float slen = _COGL_QUATERNION_NORM (quaternion);
-  float factor = 1.0f / sqrtf (slen);
-
-  quaternion->x *= factor;
-  quaternion->y *= factor;
-  quaternion->z *= factor;
-
-  quaternion->w *= factor;
-
-  return;
-}
-
-float
-cogl_quaternion_dot_product (const CoglQuaternion *a,
-                             const CoglQuaternion *b)
-{
-  return a->w * b->w + a->x * b->x + a->y * b->y + a->z * b->z;
-}
-
-void
-cogl_quaternion_invert (CoglQuaternion *quaternion)
-{
-  quaternion->x = -quaternion->x;
-  quaternion->y = -quaternion->y;
-  quaternion->z = -quaternion->z;
-}
-
-void
-cogl_quaternion_multiply (CoglQuaternion *result,
-                          const CoglQuaternion *a,
-                          const CoglQuaternion *b)
-{
-  float w = a->w;
-  float x = a->x;
-  float y = a->y;
-  float z = a->z;
-
-  _COGL_RETURN_IF_FAIL (b != result);
-
-  result->w = w * b->w - x * b->x - y * b->y - z * b->z;
-
-  result->x = w * b->x + x * b->w + y * b->z - z * b->y;
-  result->y = w * b->y + y * b->w + z * b->x - x * b->z;
-  result->z = w * b->z + z * b->w + x * b->y - y * b->x;
-}
-
-void
-cogl_quaternion_pow (CoglQuaternion *quaternion, float exponent)
-{
-  float half_angle;
-  float new_half_angle;
-  float factor;
-
-  /* Try and identify and nop identity quaternions to avoid
-   * dividing by zero */
-  if (fabs (quaternion->w) > 0.9999f)
-    return;
-
-  /* NB: We are using quaternions to represent an axis (a), angle (𝜃) pair
-   * in this form:
-   * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
-   */
-
-  /* FIXME: clamp [-1, 1] */
-  /* Extract 𝜃/2 from w */
-  half_angle = acosf (quaternion->w);
-
-  /* Compute the new 𝜃/2 */
-  new_half_angle = half_angle * exponent;
-
-  /* Compute the new w value */
-  quaternion->w = cosf (new_half_angle);
-
-  /* And new xyz values */
-  factor = sinf (new_half_angle) / sinf (half_angle);
-  quaternion->x *= factor;
-  quaternion->y *= factor;
-  quaternion->z *= factor;
-}
-
-void
-cogl_quaternion_slerp (CoglQuaternion *result,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       float t)
-{
-  float cos_difference;
-  float qb_w;
-  float qb_x;
-  float qb_y;
-  float qb_z;
-  float fa;
-  float fb;
-
-  _COGL_RETURN_IF_FAIL (t >=0 && t <= 1.0f);
-
-  if (t == 0)
-    {
-      *result = *a;
-      return;
-    }
-  else if (t == 1)
-    {
-      *result = *b;
-      return;
-    }
-
-  /* compute the cosine of the angle between the two given quaternions */
-  cos_difference = cogl_quaternion_dot_product (a, b);
-
-  /* If negative, use -b. Two quaternions q and -q represent the same angle but
-   * may produce a different slerp. We choose b or -b to rotate using the acute
-   * angle.
-   */
-  if (cos_difference < 0.0f)
-    {
-      qb_w = -b->w;
-      qb_x = -b->x;
-      qb_y = -b->y;
-      qb_z = -b->z;
-      cos_difference = -cos_difference;
-    }
-  else
-    {
-      qb_w = b->w;
-      qb_x = b->x;
-      qb_y = b->y;
-      qb_z = b->z;
-    }
-
-  /* If we have two unit quaternions the dot should be <= 1.0 */
-  g_assert (cos_difference < 1.1f);
-
-
-  /* Determine the interpolation factors for each quaternion, simply using
-   * linear interpolation for quaternions that are nearly exactly the same.
-   * (this will avoid divisions by zero)
-   */
-
-  if (cos_difference > 0.9999f)
-    {
-      fa = 1.0f - t;
-      fb = t;
-
-      /* XXX: should we also normalize() at the end in this case? */
-    }
-  else
-    {
-      /* Calculate the sin of the angle between the two quaternions using the
-       * trig identity: sin²(𝜃) + cos²(𝜃) = 1
-       */
-      float sin_difference =  sqrtf (1.0f - cos_difference * cos_difference);
-
-      float difference = atan2f (sin_difference, cos_difference);
-      float one_over_sin_difference = 1.0f / sin_difference;
-      fa = sinf ((1.0f - t) * difference) * one_over_sin_difference;
-      fb = sinf (t * difference) * one_over_sin_difference;
-    }
-
-  /* Finally interpolate the two quaternions */
-
-  result->x = fa * a->x + fb * qb_x;
-  result->y = fa * a->y + fb * qb_y;
-  result->z = fa * a->z + fb * qb_z;
-  result->w = fa * a->w + fb * qb_w;
-}
-
-void
-cogl_quaternion_nlerp (CoglQuaternion *result,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       float t)
-{
-  float cos_difference;
-  float qb_w;
-  float qb_x;
-  float qb_y;
-  float qb_z;
-  float fa;
-  float fb;
-
-  _COGL_RETURN_IF_FAIL (t >=0 && t <= 1.0f);
-
-  if (t == 0)
-    {
-      *result = *a;
-      return;
-    }
-  else if (t == 1)
-    {
-      *result = *b;
-      return;
-    }
-
-  /* compute the cosine of the angle between the two given quaternions */
-  cos_difference = cogl_quaternion_dot_product (a, b);
-
-  /* If negative, use -b. Two quaternions q and -q represent the same angle but
-   * may produce a different slerp. We choose b or -b to rotate using the acute
-   * angle.
-   */
-  if (cos_difference < 0.0f)
-    {
-      qb_w = -b->w;
-      qb_x = -b->x;
-      qb_y = -b->y;
-      qb_z = -b->z;
-      cos_difference = -cos_difference;
-    }
-  else
-    {
-      qb_w = b->w;
-      qb_x = b->x;
-      qb_y = b->y;
-      qb_z = b->z;
-    }
-
-  /* If we have two unit quaternions the dot should be <= 1.0 */
-  g_assert (cos_difference < 1.1f);
-
-  fa = 1.0f - t;
-  fb = t;
-
-  result->x = fa * a->x + fb * qb_x;
-  result->y = fa * a->y + fb * qb_y;
-  result->z = fa * a->z + fb * qb_z;
-  result->w = fa * a->w + fb * qb_w;
-
-  cogl_quaternion_normalize (result);
-}
-
-void
-cogl_quaternion_squad (CoglQuaternion *result,
-                       const CoglQuaternion *prev,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       const CoglQuaternion *next,
-                       float t)
-{
-  CoglQuaternion slerp0;
-  CoglQuaternion slerp1;
-
-  cogl_quaternion_slerp (&slerp0, a, b, t);
-  cogl_quaternion_slerp (&slerp1, prev, next, t);
-  cogl_quaternion_slerp (result, &slerp0, &slerp1, 2.0f * t * (1.0f - t));
-}
-
-const CoglQuaternion *
-cogl_get_static_identity_quaternion (void)
-{
-  return &identity_quaternion;
-}
-
-const CoglQuaternion *
-cogl_get_static_zero_quaternion (void)
-{
-  return &zero_quaternion;
-}
-

cogl/cogl/cogl-quaternion.h

@@ -1,560 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_QUATERNION_H__
-#define __COGL_QUATERNION_H__
-
-#include <cogl/cogl-types.h>
-#include <cogl/cogl-vector.h>
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-quaternion
- * @short_description: Functions for initializing and manipulating
- * quaternions.
- *
- * Quaternions have become a standard form for representing 3D
- * rotations and have some nice properties when compared with other
- * representation such as (roll,pitch,yaw) Euler angles. They can be
- * used to interpolate between different rotations and they don't
- * suffer from a problem called
- * <ulink url="http://en.wikipedia.org/wiki/Gimbal_lock">"Gimbal lock"</ulink>
- * where two of the axis of rotation may become aligned and you loose a
- * degree of freedom.
- * .
- */
-#include <cogl/cogl-vector.h>
-#include <cogl/cogl-euler.h>
-
-#include <glib-object.h>
-
-/**
- * CoglQuaternion:
- * @w: based on the angle of rotation it is cos(𝜃/2)
- * @x: based on the angle of rotation and x component of the axis of
- *     rotation it is sin(𝜃/2)*axis.x
- * @y: based on the angle of rotation and y component of the axis of
- *     rotation it is sin(𝜃/2)*axis.y
- * @z: based on the angle of rotation and z component of the axis of
- *     rotation it is sin(𝜃/2)*axis.z
- *
- * A quaternion is comprised of a scalar component and a 3D vector
- * component. The scalar component is normally referred to as w and the
- * vector might either be referred to as v or a (for axis) or expanded
- * with the individual components: (x, y, z) A full quaternion would
- * then be written as <literal>[w (x, y, z)]</literal>.
- *
- * Quaternions can be considered to represent an axis and angle
- * pair although sadly these numbers are buried somewhat under some
- * maths...
- *
- * For the curious you can see here that a given axis (a) and angle (𝜃)
- * pair are represented in a quaternion as follows:
- * |[
- * [w=cos(𝜃/2) ( x=sin(𝜃/2)*a.x, y=sin(𝜃/2)*a.y, z=sin(𝜃/2)*a.x )]
- * ]|
- *
- * Unit Quaternions:
- * When using Quaternions to represent spatial orientations for 3D
- * graphics it's always assumed you have a unit quaternion. The
- * magnitude of a quaternion is defined as:
- * |[
- * sqrt (w² + x² + y² + z²)
- * ]|
- * and a unit quaternion satisfies this equation:
- * |[
- * w² + x² + y² + z² = 1
- * ]|
- *
- * Thankfully most of the time we don't actually have to worry about
- * the maths that goes on behind the scenes but if you are curious to
- * learn more here are some external references:
- *
- * <itemizedlist>
- * <listitem>
- * <ulink url="http://mathworld.wolfram.com/Quaternion.html"/>
- * </listitem>
- * <listitem>
- * <ulink url="http://www.gamedev.net/reference/articles/article1095.asp"/>
- * </listitem>
- * <listitem>
- * <ulink url="http://www.cprogramming.com/tutorial/3d/quaternions.html"/>
- * </listitem>
- * <listitem>
- * <ulink url="http://www.isner.com/tutorials/quatSpells/quaternion_spells_12.htm"/>
- * </listitem>
- * <listitem>
- * 3D Maths Primer for Graphics and Game Development ISBN-10: 1556229119
- * </listitem>
- * <listitem>
- * <ulink url="http://www.cs.caltech.edu/courses/cs171/quatut.pdf"/>
- * </listitem>
- * <listitem>
- * <ulink url="http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56"/>
- * </listitem>
- * </itemizedlist>
- *
- */
-struct _CoglQuaternion
-{
-  /*< public >*/
-  float w;
-
-  float x;
-  float y;
-  float z;
-
-  /*< private >*/
-  float padding0;
-  float padding1;
-  float padding2;
-  float padding3;
-};
-COGL_STRUCT_SIZE_ASSERT (CoglQuaternion, 32);
-
-/**
- * cogl_quaternion_get_gtype:
- *
- * Returns: a #GType that can be used with the GLib type system.
- */
-GType cogl_quaternion_get_gtype (void);
-
-/**
- * cogl_quaternion_init:
- * @quaternion: An uninitialized #CoglQuaternion
- * @angle: The angle you want to rotate around the given axis
- * @x: The x component of your axis vector about which you want to
- * rotate.
- * @y: The y component of your axis vector about which you want to
- * rotate.
- * @z: The z component of your axis vector about which you want to
- * rotate.
- *
- * Initializes a quaternion that rotates @angle degrees around the
- * axis vector (@x, @y, @z). The axis vector does not need to be
- * normalized.
- *
- * Returns: A normalized, unit quaternion representing an orientation
- * rotated @angle degrees around the axis vector (@x, @y, @z)
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init (CoglQuaternion *quaternion,
-                      float angle,
-                      float x,
-                      float y,
-                      float z);
-
-/**
- * cogl_quaternion_init_from_angle_vector:
- * @quaternion: An uninitialized #CoglQuaternion
- * @angle: The angle to rotate around @axis3f
- * @axis3f: your 3 component axis vector about which you want to rotate.
- *
- * Initializes a quaternion that rotates @angle degrees around the
- * given @axis vector. The axis vector does not need to be
- * normalized.
- *
- * Returns: A normalized, unit quaternion representing an orientation
- * rotated @angle degrees around the given @axis vector.
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_angle_vector (CoglQuaternion *quaternion,
-                                        float angle,
-                                        const float *axis3f);
-
-/**
- * cogl_quaternion_init_identity:
- * @quaternion: An uninitialized #CoglQuaternion
- *
- * Initializes the quaternion with the canonical quaternion identity
- * [1 (0, 0, 0)] which represents no rotation. Multiplying a
- * quaternion with this identity leaves the quaternion unchanged.
- *
- * You might also want to consider using
- * cogl_get_static_identity_quaternion().
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_identity (CoglQuaternion *quaternion);
-
-/**
- * cogl_quaternion_init_from_array:
- * @quaternion: A #CoglQuaternion
- * @array: An array of 4 floats w,(x,y,z)
- *
- * Initializes a [w (x, y,z)] quaternion directly from an array of 4
- * floats: [w,x,y,z].
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_array (CoglQuaternion *quaternion,
-                                 const float *array);
-
-/**
- * cogl_quaternion_init_from_x_rotation:
- * @quaternion: An uninitialized #CoglQuaternion
- * @angle: The angle to rotate around the x axis
- *
- * XXX: check which direction this rotates
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_x_rotation (CoglQuaternion *quaternion,
-                                      float angle);
-
-/**
- * cogl_quaternion_init_from_y_rotation:
- * @quaternion: An uninitialized #CoglQuaternion
- * @angle: The angle to rotate around the y axis
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_y_rotation (CoglQuaternion *quaternion,
-                                      float angle);
-
-/**
- * cogl_quaternion_init_from_z_rotation:
- * @quaternion: An uninitialized #CoglQuaternion
- * @angle: The angle to rotate around the z axis
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_z_rotation (CoglQuaternion *quaternion,
-                                      float angle);
-
-/**
- * cogl_quaternion_init_from_euler:
- * @quaternion: A #CoglQuaternion
- * @euler: A #CoglEuler with which to initialize the quaternion
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_euler (CoglQuaternion *quaternion,
-                                 const CoglEuler *euler);
-
-/**
- * cogl_quaternion_init_from_quaternion:
- * @quaternion: A #CoglQuaternion
- * @src: A #CoglQuaternion with which to initialize @quaternion
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_init_from_quaternion (CoglQuaternion *quaternion,
-                                      CoglQuaternion *src);
-
-/**
- * cogl_quaternion_init_from_matrix:
- * @quaternion: A Cogl Quaternion
- * @matrix: A rotation matrix with which to initialize the quaternion
- *
- * Initializes a quaternion from a rotation matrix.
- *
- * Since: 1.10
- * Stability: unstable
- */
-void
-cogl_quaternion_init_from_matrix (CoglQuaternion *quaternion,
-                                  const CoglMatrix *matrix);
-
-/**
- * cogl_quaternion_equal:
- * @v1: A #CoglQuaternion
- * @v2: A #CoglQuaternion
- *
- * Compares that all the components of quaternions @a and @b are
- * equal.
- *
- * An epsilon value is not used to compare the float components, but
- * the == operator is at least used so that 0 and -0 are considered
- * equal.
- *
- * Returns: %TRUE if the quaternions are equal else %FALSE.
- *
- * Since: 2.0
- */
-gboolean
-cogl_quaternion_equal (const void *v1, const void *v2);
-
-/**
- * cogl_quaternion_copy:
- * @src: A #CoglQuaternion
- *
- * Allocates a new #CoglQuaternion on the stack and initializes it with
- * the same values as @src.
- *
- * Returns: A newly allocated #CoglQuaternion which should be freed
- * using cogl_quaternion_free()
- *
- * Since: 2.0
- */
-CoglQuaternion *
-cogl_quaternion_copy (const CoglQuaternion *src);
-
-/**
- * cogl_quaternion_free:
- * @quaternion: A #CoglQuaternion
- *
- * Frees a #CoglQuaternion that was previously allocated via
- * cogl_quaternion_copy().
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_free (CoglQuaternion *quaternion);
-
-/**
- * cogl_quaternion_get_rotation_angle:
- * @quaternion: A #CoglQuaternion
- *
- *
- * Since: 2.0
- */
-float
-cogl_quaternion_get_rotation_angle (const CoglQuaternion *quaternion);
-
-/**
- * cogl_quaternion_get_rotation_axis:
- * @quaternion: A #CoglQuaternion
- * @vector3: (out): an allocated 3-float array
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_get_rotation_axis (const CoglQuaternion *quaternion,
-                                   float *vector3);
-
-/**
- * cogl_quaternion_normalize:
- * @quaternion: A #CoglQuaternion
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_normalize (CoglQuaternion *quaternion);
-
-/**
- * cogl_quaternion_dot_product:
- * @a: A #CoglQuaternion
- * @b: A #CoglQuaternion
- *
- * Since: 2.0
- */
-float
-cogl_quaternion_dot_product (const CoglQuaternion *a,
-                             const CoglQuaternion *b);
-
-/**
- * cogl_quaternion_invert:
- * @quaternion: A #CoglQuaternion
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_invert (CoglQuaternion *quaternion);
-
-/**
- * cogl_quaternion_multiply:
- * @result: The destination #CoglQuaternion
- * @left: The second #CoglQuaternion rotation to apply
- * @right: The first #CoglQuaternion rotation to apply
- *
- * This combines the rotations of two quaternions into @result. The
- * operation is not commutative so the order is important because AxB
- * != BxA. Cogl follows the standard convention for quaternions here
- * so the rotations are applied @right to @left. This is similar to the
- * combining of matrices.
- *
- * <note>It is possible to multiply the @a quaternion in-place, so
- * @result can be equal to @a but can't be equal to @b.</note>
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_multiply (CoglQuaternion *result,
-                          const CoglQuaternion *left,
-                          const CoglQuaternion *right);
-
-/**
- * cogl_quaternion_pow:
- * @quaternion: A #CoglQuaternion
- * @exponent: the exponent
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_pow (CoglQuaternion *quaternion, float exponent);
-
-/**
- * cogl_quaternion_slerp:
- * @result: The destination #CoglQuaternion
- * @a: The first #CoglQuaternion
- * @b: The second #CoglQuaternion
- * @t: The factor in the range [0,1] used to interpolate between
- * quaternion @a and @b.
- *
- * Performs a spherical linear interpolation between two quaternions.
- *
- * Noteable properties:
- * <itemizedlist>
- * <listitem>
- * commutative: No
- * </listitem>
- * <listitem>
- * constant velocity: Yes
- * </listitem>
- * <listitem>
- * torque minimal (travels along the surface of the 4-sphere): Yes
- * </listitem>
- * <listitem>
- * more expensive than cogl_quaternion_nlerp()
- * </listitem>
- * </itemizedlist>
- */
-void
-cogl_quaternion_slerp (CoglQuaternion *result,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       float t);
-
-/**
- * cogl_quaternion_nlerp:
- * @result: The destination #CoglQuaternion
- * @a: The first #CoglQuaternion
- * @b: The second #CoglQuaternion
- * @t: The factor in the range [0,1] used to interpolate between
- * quaterion @a and @b.
- *
- * Performs a normalized linear interpolation between two quaternions.
- * That is it does a linear interpolation of the quaternion components
- * and then normalizes the result. This will follow the shortest arc
- * between the two orientations (just like the slerp() function) but
- * will not progress at a constant speed. Unlike slerp() nlerp is
- * commutative which is useful if you are blending animations
- * together. (I.e. nlerp (tmp, a, b) followed by nlerp (result, tmp,
- * d) is the same as nlerp (tmp, a, d) followed by nlerp (result, tmp,
- * b)). Finally nlerp is cheaper than slerp so it can be a good choice
- * if you don't need the constant speed property of the slerp() function.
- *
- * Notable properties:
- * <itemizedlist>
- * <listitem>
- * commutative: Yes
- * </listitem>
- * <listitem>
- * constant velocity: No
- * </listitem>
- * <listitem>
- * torque minimal (travels along the surface of the 4-sphere): Yes
- * </listitem>
- * <listitem>
- * faster than cogl_quaternion_slerp()
- * </listitem>
- * </itemizedlist>
- */
-void
-cogl_quaternion_nlerp (CoglQuaternion *result,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       float t);
-/**
- * cogl_quaternion_squad:
- * @result: The destination #CoglQuaternion
- * @prev: A #CoglQuaternion used before @a
- * @a: The first #CoglQuaternion
- * @b: The second #CoglQuaternion
- * @next: A #CoglQuaternion that will be used after @b
- * @t: The factor in the range [0,1] used to interpolate between
- * quaternion @a and @b.
- *
- *
- * Since: 2.0
- */
-void
-cogl_quaternion_squad (CoglQuaternion *result,
-                       const CoglQuaternion *prev,
-                       const CoglQuaternion *a,
-                       const CoglQuaternion *b,
-                       const CoglQuaternion *next,
-                       float t);
-
-/**
- * cogl_get_static_identity_quaternion:
- *
- * Returns a pointer to a singleton quaternion constant describing the
- * canonical identity [1 (0, 0, 0)] which represents no rotation.
- *
- * If you multiply a quaternion with the identity quaternion you will
- * get back the same value as the original quaternion.
- *
- * Returns: A pointer to an identity quaternion
- *
- * Since: 2.0
- */
-const CoglQuaternion *
-cogl_get_static_identity_quaternion (void);
-
-/**
- * cogl_get_static_zero_quaternion:
- *
- * Returns: a pointer to a singleton quaternion constant describing a
- *          rotation of 180 degrees around a degenerate axis:
- *          [0 (0, 0, 0)]
- *
- * Since: 2.0
- */
-const CoglQuaternion *
-cogl_get_static_zero_quaternion (void);
-
-G_END_DECLS
-
-#endif /* __COGL_QUATERNION_H__ */
-

cogl/cogl/cogl-types.h

@@ -114,17 +114,9 @@ void
 cogl_handle_unref (CoglHandle handle);
 
 /* We forward declare this in cogl-types to avoid circular dependencies
- * between cogl-matrix.h, cogl-euler.h and cogl-quaterion.h */
+ * between cogl-matrix.h and cogl-quaterion.h */
 typedef struct _CoglMatrix      CoglMatrix;
 
-/* Same as above we forward declared CoglQuaternion to avoid
- * circular dependencies. */
-typedef struct _CoglQuaternion CoglQuaternion;
-
-/* Same as above we forward declared CoglEuler to avoid
- * circular dependencies. */
-typedef struct _CoglEuler CoglEuler;
-
 /**
  * CoglAngle:
  *
@@ -476,41 +468,6 @@ typedef enum
   COGL_TEXTURE_NO_ATLAS       = 1 << 2
 } CoglTextureFlags;
 
-/**
- * CoglFogMode:
- * @COGL_FOG_MODE_LINEAR: Calculates the fog blend factor as:
- * |[
- *   f = end - eye_distance / end - start
- * ]|
- * @COGL_FOG_MODE_EXPONENTIAL: Calculates the fog blend factor as:
- * |[
- *   f = e ^ -(density * eye_distance)
- * ]|
- * @COGL_FOG_MODE_EXPONENTIAL_SQUARED: Calculates the fog blend factor as:
- * |[
- *   f = e ^ -(density * eye_distance)^2
- * ]|
- *
- * The fog mode determines the equation used to calculate the fogging blend
- * factor while fogging is enabled. The simplest %COGL_FOG_MODE_LINEAR mode
- * determines f as:
- *
- * |[
- *   f = end - eye_distance / end - start
- * ]|
- *
- * Where eye_distance is the distance of the current fragment in eye
- * coordinates from the origin.
- *
- * Since: 1.0
- */
-typedef enum
-{
-  COGL_FOG_MODE_LINEAR,
-  COGL_FOG_MODE_EXPONENTIAL,
-  COGL_FOG_MODE_EXPONENTIAL_SQUARED
-} CoglFogMode;
-
 /**
  * COGL_BLEND_STRING_ERROR:
  *

cogl/cogl/cogl-vector.c

@@ -1,298 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#include "cogl-config.h"
-
-#include <cogl-util.h>
-#include <cogl-vector.h>
-
-#include <glib.h>
-#include <math.h>
-#include <string.h>
-
-#define X 0
-#define Y 1
-#define Z 2
-#define W 3
-
-void
-cogl_vector3_init (float *vector, float x, float y, float z)
-{
-  vector[X] = x;
-  vector[Y] = y;
-  vector[Z] = z;
-}
-
-void
-cogl_vector3_init_zero (float *vector)
-{
-  memset (vector, 0, sizeof (float) * 3);
-}
-
-gboolean
-cogl_vector3_equal (const void *v1, const void *v2)
-{
-  float *vector0 = (float *)v1;
-  float *vector1 = (float *)v2;
-
-  _COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
-  _COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
-
-  /* There's no point picking an arbitrary epsilon that's appropriate
-   * for comparing the components so we just use == that will at least
-   * consider -0 and 0 to be equal. */
-  return
-    vector0[X] == vector1[X] &&
-    vector0[Y] == vector1[Y] &&
-    vector0[Z] == vector1[Z];
-}
-
-gboolean
-cogl_vector3_equal_with_epsilon (const float *vector0,
-                                 const float *vector1,
-                                 float epsilon)
-{
-  _COGL_RETURN_VAL_IF_FAIL (vector0 != NULL, FALSE);
-  _COGL_RETURN_VAL_IF_FAIL (vector1 != NULL, FALSE);
-
-  if (fabsf (vector0[X] - vector1[X]) < epsilon &&
-      fabsf (vector0[Y] - vector1[Y]) < epsilon &&
-      fabsf (vector0[Z] - vector1[Z]) < epsilon)
-    return TRUE;
-  else
-    return FALSE;
-}
-
-float *
-cogl_vector3_copy (const float *vector)
-{
-  if (vector)
-    return g_slice_copy (sizeof (float) * 3, vector);
-  return NULL;
-}
-
-void
-cogl_vector3_free (float *vector)
-{
-  g_slice_free1 (sizeof (float) * 3, vector);
-}
-
-void
-cogl_vector3_invert (float *vector)
-{
-  vector[X] = -vector[X];
-  vector[Y] = -vector[Y];
-  vector[Z] = -vector[Z];
-}
-
-void
-cogl_vector3_add (float *result,
-                  const float *a,
-                  const float *b)
-{
-  result[X] = a[X] + b[X];
-  result[Y] = a[Y] + b[Y];
-  result[Z] = a[Z] + b[Z];
-}
-
-void
-cogl_vector3_subtract (float *result,
-                       const float *a,
-                       const float *b)
-{
-  result[X] = a[X] - b[X];
-  result[Y] = a[Y] - b[Y];
-  result[Z] = a[Z] - b[Z];
-}
-
-void
-cogl_vector3_multiply_scalar (float *vector,
-                              float scalar)
-{
-  vector[X] *= scalar;
-  vector[Y] *= scalar;
-  vector[Z] *= scalar;
-}
-
-void
-cogl_vector3_divide_scalar (float *vector,
-                            float scalar)
-{
-  float one_over_scalar = 1.0f / scalar;
-  vector[X] *= one_over_scalar;
-  vector[Y] *= one_over_scalar;
-  vector[Z] *= one_over_scalar;
-}
-
-void
-cogl_vector3_normalize (float *vector)
-{
-  float mag_squared =
-    vector[X] * vector[X] +
-    vector[Y] * vector[Y] +
-    vector[Z] * vector[Z];
-
-  if (mag_squared > 0.0f)
-    {
-      float one_over_mag = 1.0f / sqrtf (mag_squared);
-      vector[X] *= one_over_mag;
-      vector[Y] *= one_over_mag;
-      vector[Z] *= one_over_mag;
-    }
-}
-
-float
-cogl_vector3_magnitude (const float *vector)
-{
-  return sqrtf (vector[X] * vector[X] +
-                vector[Y] * vector[Y] +
-                vector[Z] * vector[Z]);
-}
-
-void
-cogl_vector3_cross_product (float *result,
-                            const float *a,
-                            const float *b)
-{
-  float tmp[3];
-
-  tmp[X] = a[Y] * b[Z] - a[Z] * b[Y];
-  tmp[Y] = a[Z] * b[X] - a[X] * b[Z];
-  tmp[Z] = a[X] * b[Y] - a[Y] * b[X];
-  result[X] = tmp[X];
-  result[Y] = tmp[Y];
-  result[Z] = tmp[Z];
-}
-
-float
-cogl_vector3_dot_product (const float *a, const float *b)
-{
-  return a[X] * b[X] + a[Y] * b[Y] + a[Z] * b[Z];
-}
-
-float
-cogl_vector3_distance (const float *a, const float *b)
-{
-  float dx = b[X] - a[X];
-  float dy = b[Y] - a[Y];
-  float dz = b[Z] - a[Z];
-
-  return sqrtf (dx * dx + dy * dy + dz * dz);
-}
-
-#if 0
-void
-cogl_vector4_init (float *vector, float x, float y, float z)
-{
-  vector[X] = x;
-  vector[Y] = y;
-  vector[Z] = z;
-  vector[W] = w;
-}
-
-void
-cogl_vector4_init_zero (float *vector)
-{
-  memset (vector, 0, sizeof (CoglVector4));
-}
-
-void
-cogl_vector4_init_from_vector4 (float *vector, float *src)
-{
-  *vector4 = *src;
-}
-
-gboolean
-cogl_vector4_equal (const void *v0, const void *v1)
-{
-  _COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
-  _COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
-
-  return memcmp (v1, v2, sizeof (float) * 4) == 0 ? TRUE : FALSE;
-}
-
-float *
-cogl_vector4_copy (float *vector)
-{
-  if (vector)
-    return g_slice_dup (CoglVector4, vector);
-  return NULL;
-}
-
-void
-cogl_vector4_free (float *vector)
-{
-  g_slice_free (CoglVector4, vector);
-}
-
-void
-cogl_vector4_invert (float *vector)
-{
-  vector.x = -vector.x;
-  vector.y = -vector.y;
-  vector.z = -vector.z;
-  vector.w = -vector.w;
-}
-
-void
-cogl_vector4_add (float *result,
-                  float *a,
-                  float *b)
-{
-  result.x = a.x + b.x;
-  result.y = a.y + b.y;
-  result.z = a.z + b.z;
-  result.w = a.w + b.w;
-}
-
-void
-cogl_vector4_subtract (float *result,
-                       float *a,
-                       float *b)
-{
-  result.x = a.x - b.x;
-  result.y = a.y - b.y;
-  result.z = a.z - b.z;
-  result.w = a.w - b.w;
-}
-
-void
-cogl_vector4_divide (float *vector,
-                     float scalar)
-{
-  float one_over_scalar = 1.0f / scalar;
-  result.x *= one_over_scalar;
-  result.y *= one_over_scalar;
-  result.z *= one_over_scalar;
-  result.w *= one_over_scalar;
-}
-
-#endif

cogl/cogl/cogl-vector.h

@@ -1,356 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2008,2009,2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_VECTOR_H
-#define __COGL_VECTOR_H
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-vector
- * @short_description: Functions for handling single precision float
- *                     vectors.
- *
- * This exposes a utility API that can be used for basic manipulation of 3
- * component float vectors.
- */
-
-/**
- * cogl_vector3_init:
- * @vector: The 3 component vector you want to initialize
- * @x: The x component
- * @y: The y component
- * @z: The z component
- *
- * Initializes a 3 component, single precision float vector which can
- * then be manipulated with the cogl_vector convenience APIs. Vectors
- * can also be used in places where a "point" is often desired.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_init (float *vector, float x, float y, float z);
-
-/**
- * cogl_vector3_init_zero:
- * @vector: The 3 component vector you want to initialize
- *
- * Initializes a 3 component, single precision float vector with zero
- * for each component.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_init_zero (float *vector);
-
-/**
- * cogl_vector3_equal:
- * @v1: The first 3 component vector you want to compare
- * @v2: The second 3 component vector you want to compare
- *
- * Compares the components of two vectors and returns TRUE if they are
- * the same.
- *
- * The comparison of the components is done with the '==' operator
- * such that -0 is considered equal to 0, but otherwise there is no
- * fuzziness such as an epsilon to consider vectors that are
- * essentially identical except for some minor precision error
- * differences due to the way they have been manipulated.
- *
- * Returns: TRUE if the vectors are equal else FALSE.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_vector3_equal (const void *v1, const void *v2);
-
-/**
- * cogl_vector3_equal_with_epsilon:
- * @vector0: The first 3 component vector you want to compare
- * @vector1: The second 3 component vector you want to compare
- * @epsilon: The allowable difference between components to still be
- *           considered equal
- *
- * Compares the components of two vectors using the given epsilon and
- * returns TRUE if they are the same, using an internal epsilon for
- * comparing the floats.
- *
- * Each component is compared against the epsilon value in this way:
- * |[
- *   if (fabsf (vector0->x - vector1->x) < epsilon)
- * ]|
- *
- * Returns: TRUE if the vectors are equal else FALSE.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_vector3_equal_with_epsilon (const float *vector0,
-                                 const float *vector1,
-                                 float epsilon);
-
-/**
- * cogl_vector3_copy:
- * @vector: The 3 component vector you want to copy
- *
- * Allocates a new 3 component float vector on the heap initializing
- * the components from the given @vector and returns a pointer to the
- * newly allocated vector. You should free the memory using
- * cogl_vector3_free()
- *
- * Returns: A newly allocated 3 component float vector
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float *
-cogl_vector3_copy (const float *vector);
-
-/**
- * cogl_vector3_free:
- * @vector: The 3 component you want to free
- *
- * Frees a 3 component vector that was previously allocated with
- * cogl_vector3_copy()
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_free (float *vector);
-
-/**
- * cogl_vector3_invert:
- * @vector: The 3 component vector you want to manipulate
- *
- * Inverts/negates all the components of the given @vector.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_invert (float *vector);
-
-/**
- * cogl_vector3_add:
- * @result: Where you want the result written
- * @a: The first vector operand
- * @b: The second vector operand
- *
- * Adds each of the corresponding components in vectors @a and @b
- * storing the results in @result.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_add (float *result,
-                  const float *a,
-                  const float *b);
-
-/**
- * cogl_vector3_subtract:
- * @result: Where you want the result written
- * @a: The first vector operand
- * @b: The second vector operand
- *
- * Subtracts each of the corresponding components in vector @b from
- * @a storing the results in @result.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_subtract (float *result,
-                       const float *a,
-                       const float *b);
-
-/**
- * cogl_vector3_multiply_scalar:
- * @vector: The 3 component vector you want to manipulate
- * @scalar: The scalar you want to multiply the vector components by
- *
- * Multiplies each of the @vector components by the given scalar.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_multiply_scalar (float *vector,
-                              float scalar);
-
-/**
- * cogl_vector3_divide_scalar:
- * @vector: The 3 component vector you want to manipulate
- * @scalar: The scalar you want to divide the vector components by
- *
- * Divides each of the @vector components by the given scalar.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_divide_scalar (float *vector,
-                            float scalar);
-
-/**
- * cogl_vector3_normalize:
- * @vector: The 3 component vector you want to manipulate
- *
- * Updates the vector so it is a "unit vector" such that the
- * @vector<!-- -->s magnitude or length is equal to 1.
- *
- * <note>It's safe to use this function with the [0, 0, 0] vector, it will not
- * try to divide components by 0 (its norm) and will leave the vector
- * untouched.</note>
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_normalize (float *vector);
-
-/**
- * cogl_vector3_magnitude:
- * @vector: The 3 component vector you want the magnitude for
- *
- * Calculates the scalar magnitude or length of @vector.
- *
- * Returns: The magnitude of @vector.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_magnitude (const float *vector);
-
-/**
- * cogl_vector3_cross_product:
- * @result: Where you want the result written
- * @u: Your first 3 component vector
- * @v: Your second 3 component vector
- *
- * Calculates the cross product between the two vectors @u and @v.
- *
- * The cross product is a vector perpendicular to both @u and @v. This
- * can be useful for calculating the normal of a polygon by creating
- * two vectors in its plane using the polygons vertices and taking
- * their cross product.
- *
- * If the two vectors are parallel then the cross product is 0.
- *
- * You can use a right hand rule to determine which direction the
- * perpendicular vector will point: If you place the two vectors tail,
- * to tail and imagine grabbing the perpendicular line that extends
- * through the common tail with your right hand such that you fingers
- * rotate in the direction from @u to @v then the resulting vector
- * points along your extended thumb.
- *
- * Returns: The cross product between two vectors @u and @v.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_cross_product (float *result,
-                            const float *u,
-                            const float *v);
-
-/**
- * cogl_vector3_dot_product:
- * @a: Your first 3 component vector
- * @b: Your second 3 component vector
- *
- * Calculates the dot product of the two 3 component vectors. This
- * can be used to determine the magnitude of one vector projected onto
- * another. (for example a surface normal)
- *
- * For example if you have a polygon with a given normal vector and
- * some other point for which you want to calculate its distance from
- * the polygon, you can create a vector between one of the polygon
- * vertices and that point and use the dot product to calculate the
- * magnitude for that vector but projected onto the normal of the
- * polygon. This way you don't just get the distance from the point to
- * the edge of the polygon you get the distance from the point to the
- * nearest part of the polygon.
- *
- * <note>If you don't use a unit length normal in the above example
- * then you would then also have to divide the result by the magnitude
- * of the normal</note>
- *
- * The dot product is calculated as:
- * |[
- *  (a->x * b->x + a->y * b->y + a->z * b->z)
- * ]|
- *
- * For reference, the dot product can also be calculated from the
- * angle between two vectors as:
- * |[
- *  |a||b|cos𝜃
- * ]|
- *
- * Returns: The dot product of two vectors.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_dot_product (const float *a, const float *b);
-
-/**
- * cogl_vector3_distance:
- * @a: The first point
- * @b: The second point
- *
- * If you consider the two given vectors as (x,y,z) points instead
- * then this will compute the distance between those two points.
- *
- * Returns: The distance between two points given as 3 component
- *          vectors.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_distance (const float *a, const float *b);
-
-G_END_DECLS
-
-#endif /* __COGL_VECTOR_H */
-

cogl/cogl/cogl.c

@@ -279,37 +279,6 @@ cogl_get_bitmasks (int *red,
     *alpha = cogl_framebuffer_get_alpha_bits (framebuffer);
 }
 
-void
-cogl_set_fog (const CoglColor *fog_color,
-              CoglFogMode      mode,
-              float            density,
-              float            z_near,
-              float            z_far)
-{
-  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
-  if (ctx->legacy_fog_state.enabled == FALSE)
-    ctx->legacy_state_set++;
-
-  ctx->legacy_fog_state.enabled = TRUE;
-  ctx->legacy_fog_state.color = *fog_color;
-  ctx->legacy_fog_state.mode = mode;
-  ctx->legacy_fog_state.density = density;
-  ctx->legacy_fog_state.z_near = z_near;
-  ctx->legacy_fog_state.z_far = z_far;
-}
-
-void
-cogl_disable_fog (void)
-{
-  _COGL_GET_CONTEXT (ctx, NO_RETVAL);
-
-  if (ctx->legacy_fog_state.enabled == TRUE)
-    ctx->legacy_state_set--;
-
-  ctx->legacy_fog_state.enabled = FALSE;
-}
-
 void
 cogl_flush (void)
 {

cogl/cogl/cogl.h

@@ -42,6 +42,8 @@
 #define __COGL_MUST_UNDEF_COGL_H_INSIDE__
 #endif
 
+#include <graphene.h>
+
 /* We currently keep gtype integration delimited in case we eventually
  * want to split it out into a separate utility library when Cogl
  * becomes a standalone project. (like cairo-gobject.so)
@@ -61,6 +63,7 @@
 #include <cogl/cogl1-context.h>
 #include <cogl/cogl-bitmap.h>
 #include <cogl/cogl-color.h>
+#include <cogl/cogl-graphene-utils.h>
 #include <cogl/cogl-matrix.h>
 #include <cogl/cogl-matrix-stack.h>
 #include <cogl/cogl-offscreen.h>
@@ -100,9 +103,6 @@
 #include <cogl/cogl-context.h>
 #include <cogl/cogl-buffer.h>
 #include <cogl/cogl-pixel-buffer.h>
-#include <cogl/cogl-vector.h>
-#include <cogl/cogl-euler.h>
-#include <cogl/cogl-quaternion.h>
 #include <cogl/cogl-texture-2d.h>
 #include <cogl/cogl-texture-2d-gl.h>
 #include <cogl/cogl-texture-rectangle.h>

cogl/cogl/cogl.symbols

@@ -187,8 +187,6 @@ cogl_depth_state_set_range
 cogl_depth_state_set_write_enabled
 cogl_depth_test_function_get_type
 
-cogl_disable_fog
-
 #ifdef COGL_HAS_GTYPE_SUPPORT
 cogl_display_get_gtype
 #endif
@@ -205,19 +203,6 @@ cogl_error_copy
 cogl_error_free
 cogl_error_matches
 
-cogl_euler_copy
-cogl_euler_equal
-cogl_euler_free
-#ifdef COGL_HAS_GTYPE_SUPPORT
-cogl_euler_get_gtype
-#endif
-cogl_euler_init
-cogl_euler_init_from_matrix
-#if 0
-/* not yet implemented */
-cogl_euler_init_from_quaternion
-#endif
-
 cogl_features_available
 cogl_feature_flags_get_type
 cogl_fence_closure_get_user_data
@@ -232,8 +217,6 @@ cogl_fixed_sin
 cogl_fixed_sqrt
 cogl_fixed_tan
 
-cogl_fog_mode_get_type
-
 cogl_foreach_feature
 
 cogl_flush
@@ -503,9 +486,6 @@ cogl_matrix_init_from_quaternion
 cogl_matrix_init_identity
 cogl_matrix_look_at
 cogl_matrix_multiply
-#ifndef COGL_DISABLE_DEPRECATED
-cogl_matrix_ortho
-#endif
 cogl_matrix_orthographic
 cogl_matrix_perspective
 cogl_matrix_project_points
@@ -537,6 +517,7 @@ cogl_matrix_stack_rotate_quaternion
 cogl_matrix_stack_scale
 cogl_matrix_stack_set
 cogl_matrix_stack_translate
+cogl_matrix_to_graphene_matrix
 cogl_matrix_transform_point
 cogl_matrix_transform_points
 cogl_matrix_translate
@@ -766,31 +747,6 @@ cogl_push_gles2_context
 cogl_push_matrix
 cogl_push_source
 
-cogl_quaternion_copy
-cogl_quaternion_dot_product
-cogl_quaternion_equal
-cogl_quaternion_free
-#ifdef COGL_HAS_GTYPE_SUPPORT
-cogl_quaternion_get_gtype
-#endif
-cogl_quaternion_get_rotation_angle
-cogl_quaternion_get_rotation_axis
-cogl_quaternion_init
-cogl_quaternion_init_from_angle_vector
-cogl_quaternion_init_from_array
-cogl_quaternion_init_from_euler
-cogl_quaternion_init_from_x_rotation
-cogl_quaternion_init_from_y_rotation
-cogl_quaternion_init_from_z_rotation
-cogl_quaternion_init_identity
-cogl_quaternion_invert
-cogl_quaternion_multiply
-cogl_quaternion_nlerp
-cogl_quaternion_normalize
-cogl_quaternion_pow
-cogl_quaternion_slerp
-cogl_quaternion_squad
-
 cogl_read_pixels
 cogl_read_pixels_flags_get_type
 
@@ -825,7 +781,6 @@ cogl_set_depth_test_enabled
 #ifndef COGL_DISABLE_DEPRECATED
 cogl_set_draw_buffer
 #endif
-cogl_set_fog
 #ifdef COGL_HAS_SDL_SUPPORT
 cogl_sdl_context_new
 cogl_sdl_handle_event
@@ -969,23 +924,6 @@ cogl_texture_3d_new_with_size
 cogl_transform
 cogl_translate
 
-cogl_vector3_add
-cogl_vector3_copy
-cogl_vector3_cross_product
-cogl_vector3_distance
-cogl_vector3_divide_scalar
-cogl_vector3_dot_product
-cogl_vector3_equal
-cogl_vector3_equal_with_epsilon
-cogl_vector3_free
-cogl_vector3_init
-cogl_vector3_init_zero
-cogl_vector3_invert
-cogl_vector3_magnitude
-cogl_vector3_multiply_scalar
-cogl_vector3_normalize
-cogl_vector3_subtract
-
 cogl_vertex_buffer_add
 cogl_vertex_buffer_delete
 cogl_vertex_buffer_disable
@@ -1076,3 +1014,5 @@ _cogl_texture_get_format
 cogl_fence_closure_get_user_data
 cogl_framebuffer_add_fence_callback
 cogl_framebuffer_cancel_fence_callback
+
+graphene_matrix_to_cogl_matrix

cogl/cogl/cogl1-context.h

@@ -496,53 +496,6 @@ COGL_DEPRECATED_FOR (cogl_pipeline_get_cull_face_mode)
 gboolean
 cogl_get_backface_culling_enabled (void);
 
-/**
- * cogl_set_fog:
- * @fog_color: The color of the fog
- * @mode: A #CoglFogMode that determines the equation used to calculate the
- *   fogging blend factor.
- * @density: Used by %COGL_FOG_MODE_EXPONENTIAL and by
- *   %COGL_FOG_MODE_EXPONENTIAL_SQUARED equations.
- * @z_near: Position along Z axis where no fogging should be applied
- * @z_far: Position along Z axis where full fogging should be applied
- *
- * Enables fogging. Fogging causes vertices that are further away from the eye
- * to be rendered with a different color. The color is determined according to
- * the chosen fog mode; at it's simplest the color is linearly interpolated so
- * that vertices at @z_near are drawn fully with their original color and
- * vertices at @z_far are drawn fully with @fog_color. Fogging will remain
- * enabled until you call cogl_disable_fog().
- *
- * <note>The fogging functions only work correctly when primitives use
- * unmultiplied alpha colors. By default Cogl will premultiply textures
- * and cogl_set_source_color() will premultiply colors, so unless you
- * explicitly load your textures requesting an unmultiplied internal format
- * and use cogl_material_set_color() you can only use fogging with fully
- * opaque primitives. This might improve in the future when we can depend
- * on fragment shaders.</note>
- *
- * Deprecated: 1.16: Use #CoglSnippet shader api for fog
- */
-COGL_DEPRECATED_FOR (cogl_snippet_API)
-void
-cogl_set_fog (const CoglColor *fog_color,
-              CoglFogMode mode,
-              float density,
-              float z_near,
-              float z_far);
-
-/**
- * cogl_disable_fog:
- *
- * This function disables fogging, so primitives drawn afterwards will not be
- * blended with any previously set fog color.
- *
- * Deprecated: 1.16: Use #CoglSnippet shader api for fog
- */
-COGL_DEPRECATED_FOR (cogl_snippet_API)
-void
-cogl_disable_fog (void);
-
 /**
  * cogl_clear:
  * @color: Background color to clear to
@@ -819,8 +772,7 @@ cogl_flush (void);
  *
  * The result is that the OpenGL modelview matrix will be setup; the state
  * corresponding to the current source material will be set up and other world
- * state such as backface culling, depth and fogging enabledness will be sent
- * to OpenGL.
+ * state such as backface culling and depth enabledness will be sent to OpenGL.
  *
  * <note>No special material state is flushed, so if you want Cogl to setup a
  * simplified material state it is your responsibility to set a simple source

cogl/cogl/driver/gl/cogl-clip-stack-gl.c

@@ -50,6 +50,127 @@
 #define GL_CLIP_PLANE5 0x3005
 #endif
 
+
+static void
+flush_matrix_to_gl_builtin (CoglContext    *ctx,
+                            gboolean        is_identity,
+                            CoglMatrix     *matrix,
+                            CoglMatrixMode  mode)
+{
+  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
+
+#ifdef HAVE_COGL_GL
+  if (ctx->flushed_matrix_mode != mode)
+    {
+      GLenum gl_mode = 0;
+
+      switch (mode)
+        {
+        case COGL_MATRIX_MODELVIEW:
+          gl_mode = GL_MODELVIEW;
+          break;
+
+        case COGL_MATRIX_PROJECTION:
+          gl_mode = GL_PROJECTION;
+          break;
+
+        case COGL_MATRIX_TEXTURE:
+          gl_mode = GL_TEXTURE;
+          break;
+        }
+
+      GE (ctx, glMatrixMode (gl_mode));
+      ctx->flushed_matrix_mode = mode;
+    }
+
+  if (is_identity)
+    {
+      GE (ctx, glLoadIdentity ());
+    }
+  else
+    {
+      float array[16];
+      cogl_matrix_get_array (matrix, array);
+      GE (ctx, glLoadMatrixf (array));
+    }
+#endif
+}
+
+static void
+flush_matrix_entry_to_gl_builtins (CoglContext     *ctx,
+                                   CoglMatrixEntry *entry,
+                                   CoglMatrixMode   mode,
+                                   CoglFramebuffer *framebuffer,
+                                   gboolean         disable_flip)
+{
+  g_assert (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED));
+
+#ifdef HAVE_COGL_GL
+  {
+    gboolean needs_flip;
+    CoglMatrixEntryCache *cache;
+
+    if (mode == COGL_MATRIX_PROJECTION)
+      {
+        /* Because Cogl defines texture coordinates to have a top left
+         * origin and because offscreen framebuffers may be used for
+         * rendering to textures we always render upside down to
+         * offscreen buffers. Also for some backends we need to render
+         * onscreen buffers upside-down too.
+         */
+        if (disable_flip)
+          needs_flip = FALSE;
+        else
+          needs_flip = cogl_is_offscreen (framebuffer);
+
+        cache = &ctx->builtin_flushed_projection;
+      }
+    else
+      {
+        needs_flip = FALSE;
+
+        if (mode == COGL_MATRIX_MODELVIEW)
+          cache = &ctx->builtin_flushed_modelview;
+        else
+          cache = NULL;
+      }
+
+    /* We don't need to do anything if the state is the same */
+    if (!cache ||
+        _cogl_matrix_entry_cache_maybe_update (cache, entry, needs_flip))
+      {
+        gboolean is_identity;
+        CoglMatrix matrix;
+
+        if (entry->op == COGL_MATRIX_OP_LOAD_IDENTITY)
+          is_identity = TRUE;
+        else
+          {
+            is_identity = FALSE;
+            cogl_matrix_entry_get (entry, &matrix);
+          }
+
+        if (needs_flip)
+          {
+            CoglMatrix flipped_matrix;
+
+            cogl_matrix_multiply (&flipped_matrix,
+                                  &ctx->y_flip_matrix,
+                                  is_identity ?
+                                  &ctx->identity_matrix :
+                                  &matrix);
+
+            flush_matrix_to_gl_builtin (ctx, FALSE, &flipped_matrix, mode);
+          }
+        else
+          {
+            flush_matrix_to_gl_builtin (ctx, is_identity, &matrix, mode);
+          }
+      }
+  }
+#endif
+}
+
 static void
 project_vertex (const CoglMatrix *modelview_projection,
 		float *vertex)
@@ -106,11 +227,11 @@ set_clip_plane (CoglFramebuffer *framebuffer,
   /* Clip planes can only be used when a fixed function backend is in
      use so we know we can directly push this matrix to the builtin
      state */
-  _cogl_matrix_entry_flush_to_gl_builtins (ctx,
-                                           modelview_stack->last_entry,
-                                           COGL_MATRIX_MODELVIEW,
-                                           framebuffer,
-                                           FALSE /* don't disable flip */);
+  flush_matrix_entry_to_gl_builtins (ctx,
+                                     modelview_stack->last_entry,
+                                     COGL_MATRIX_MODELVIEW,
+                                     framebuffer,
+                                     FALSE /* don't disable flip */);
 
   planef[0] = 0;
   planef[1] = -1.0;

cogl/cogl/driver/gl/cogl-pipeline-progend-glsl.c

@@ -440,10 +440,10 @@ update_constants_cb (CoglPipeline *pipeline,
       (state->update_all || unit_state->dirty_texture_matrix))
     {
       const CoglMatrix *matrix;
-      const float *array;
+      float array[16];
 
       matrix = _cogl_pipeline_get_layer_matrix (pipeline, layer_index);
-      array = cogl_matrix_get_array (matrix);
+      cogl_matrix_get_array (matrix, array);
       GE (ctx, glUniformMatrix4fv (unit_state->texture_matrix_uniform,
                                    1, FALSE, array));
       unit_state->dirty_texture_matrix = FALSE;
@@ -965,6 +965,8 @@ _cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline,
 
   if (modelview_changed || projection_changed)
     {
+      float array[16];
+
       if (program_state->mvp_uniform != -1)
         need_modelview = need_projection = TRUE;
       else
@@ -992,16 +994,22 @@ _cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline,
         }
 
       if (projection_changed && program_state->projection_uniform != -1)
-        GE (ctx, glUniformMatrix4fv (program_state->projection_uniform,
-                                     1, /* count */
-                                     FALSE, /* transpose */
-                                     cogl_matrix_get_array (&projection)));
+        {
+          cogl_matrix_get_array (&projection, array);
+          GE (ctx, glUniformMatrix4fv (program_state->projection_uniform,
+                                       1, /* count */
+                                       FALSE, /* transpose */
+                                       array));
+        }
 
       if (modelview_changed && program_state->modelview_uniform != -1)
-        GE (ctx, glUniformMatrix4fv (program_state->modelview_uniform,
-                                     1, /* count */
-                                     FALSE, /* transpose */
-                                     cogl_matrix_get_array (&modelview)));
+        {
+          cogl_matrix_get_array (&modelview, array);
+          GE (ctx, glUniformMatrix4fv (program_state->modelview_uniform,
+                                       1, /* count */
+                                       FALSE, /* transpose */
+                                       array));
+        }
 
       if (program_state->mvp_uniform != -1)
         {
@@ -1010,11 +1018,12 @@ _cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline,
              avoiding the matrix multiplication */
           if (cogl_matrix_entry_is_identity (modelview_entry))
             {
+              cogl_matrix_get_array (&projection, array);
               GE (ctx,
                   glUniformMatrix4fv (program_state->mvp_uniform,
                                       1, /* count */
                                       FALSE, /* transpose */
-                                      cogl_matrix_get_array (&projection)));
+                                      array));
             }
           else
             {
@@ -1023,11 +1032,12 @@ _cogl_pipeline_progend_glsl_pre_paint (CoglPipeline *pipeline,
               cogl_matrix_multiply (&combined,
                                     &projection,
                                     &modelview);
+              cogl_matrix_get_array (&combined, array);
               GE (ctx,
                   glUniformMatrix4fv (program_state->mvp_uniform,
                                       1, /* count */
                                       FALSE, /* transpose */
-                                      cogl_matrix_get_array (&combined)));
+                                      array));
             }
         }
     }

cogl/cogl/gl-prototypes/cogl-fixed-functions.h

@@ -65,10 +65,6 @@ COGL_EXT_BEGIN (fixed_function_core,
                 "\0")
 COGL_EXT_FUNCTION (void, glAlphaFunc,
                    (GLenum func, GLclampf ref))
-COGL_EXT_FUNCTION (void, glFogf,
-                   (GLenum pname, GLfloat param))
-COGL_EXT_FUNCTION (void, glFogfv,
-                   (GLenum pname, const GLfloat *params))
 COGL_EXT_FUNCTION (void, glLoadMatrixf,
                    (const GLfloat *m))
 COGL_EXT_FUNCTION (void, glMaterialfv,

cogl/cogl/libmutter-cogl.map

@@ -48,6 +48,7 @@ global:
   _cogl_pixel_format_get_bytes_per_pixel*;
   _cogl_system_error_quark;
   _cogl_util_next_p2;
+  graphene_matrix_to_cogl_matrix;
 local:
   *;
 };

cogl/cogl/meson.build

@@ -98,6 +98,7 @@ cogl_headers = [
 
 cogl_nonintrospected_headers = [
   'cogl-deprecated.h',
+  'cogl-graphene-utils.h',
   'cogl-pango.h',
   'cogl-renderer.h',
   'cogl-swap-chain.h',
@@ -113,10 +114,7 @@ cogl_nonintrospected_headers = [
   'cogl-attribute.h',
   'cogl-primitive.h',
   'cogl-frame-info.h',
-  'cogl-vector.h',
-  'cogl-euler.h',
   'cogl-output.h',
-  'cogl-quaternion.h',
   'cogl-matrix-stack.h',
   'cogl-poll.h',
   'cogl-texture-3d.h',
@@ -217,6 +215,7 @@ cogl_sources = [
   'cogl-i18n-private.h',
   'cogl-debug.h',
   'cogl-debug-options.h',
+  'cogl-graphene-utils.c',
   'cogl-gpu-info.c',
   'cogl-gpu-info-private.h',
   'cogl-context-private.h',
@@ -269,10 +268,6 @@ cogl_sources = [
   'cogl-primitive-private.h',
   'cogl-primitive.c',
   'cogl-matrix.c',
-  'cogl-vector.c',
-  'cogl-euler.c',
-  'cogl-quaternion-private.h',
-  'cogl-quaternion.c',
   'cogl-matrix-private.h',
   'cogl-matrix-stack.c',
   'cogl-matrix-stack-private.h',
@@ -495,7 +490,7 @@ if have_introspection
     sources: cogl_introspected_headers,
     nsversion: libmutter_api_version,
     namespace: 'Cogl',
-    includes: ['GL-1.0', 'GObject-2.0'],
+    includes: ['GL-1.0', 'GObject-2.0', 'Graphene-1.0'],
     dependencies: [cogl_deps],
     extra_args: introspection_args + [
       '-UCOGL_COMPILATION',

cogl/meson.build

@@ -24,6 +24,7 @@ cogl_mutter_config_h = configure_file(
 cogl_pkg_deps = [
   glib_dep,
   gobject_dep,
+  graphene_dep,
 ]
 
 cogl_pkg_private_deps = [

cogl/tests/conform/test-color-mask.c

@@ -19,34 +19,26 @@ typedef struct _TestState
 static void
 paint (TestState *state)
 {
+  CoglPipeline *pipeline;
   CoglColor bg;
   int i;
 
-  cogl_set_source_color4ub (255, 255, 255, 255);
+  pipeline = cogl_pipeline_new (test_ctx);
+  cogl_pipeline_set_color4ub (pipeline, 255, 255, 255, 255);
 
-  /* We push the third framebuffer first so that later we can switch
-     back to it by popping to test that that works */
-  cogl_push_framebuffer (state->fbo[2]);
-
-  cogl_push_framebuffer (state->fbo[0]);
-  cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
-  cogl_pop_framebuffer ();
-
-  cogl_push_framebuffer (state->fbo[1]);
-  cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
-  cogl_pop_framebuffer ();
-
-  /* We should now be back on the third framebuffer */
-  cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
-  cogl_pop_framebuffer ();
+  cogl_framebuffer_draw_rectangle (state->fbo[0], pipeline, -1.0, -1.0, 1.0, 1.0);
+  cogl_framebuffer_draw_rectangle (state->fbo[1], pipeline, -1.0, -1.0, 1.0, 1.0);
+  cogl_framebuffer_draw_rectangle (state->fbo[2], pipeline, -1.0, -1.0, 1.0, 1.0);
 
   cogl_color_init_from_4ub (&bg, 128, 128, 128, 255);
-  cogl_clear (&bg, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH);
+  cogl_framebuffer_clear (test_fb, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH, &bg);
+
+  cogl_object_unref (pipeline);
 
   /* Render all of the textures to the screen */
   for (i = 0; i < NUM_FBOS; i++)
     {
-      CoglPipeline *pipeline = cogl_pipeline_new (test_ctx);
+      pipeline = cogl_pipeline_new (test_ctx);
       cogl_pipeline_set_layer_texture (pipeline, 0, state->tex[i]);
       cogl_framebuffer_draw_rectangle (test_fb, pipeline,
                                        2.0f / NUM_FBOS * i - 1.0f, -1.0f,
@@ -99,11 +91,7 @@ test_color_mask (void)
                                        COGL_COLOR_MASK_BLUE);
     }
 
-  /* XXX: we have to push/pop a framebuffer since this test currently
-   * uses the legacy cogl_rectangle() api. */
-  cogl_push_framebuffer (test_fb);
   paint (&state);
-  cogl_pop_framebuffer ();
 
   if (cogl_test_verbose ())
     g_print ("OK\n");

cogl/tests/conform/test-conform-main.c

@@ -139,7 +139,7 @@ main (int argc, char **argv)
             TEST_REQUIREMENT_GLES2_CONTEXT,
             0);
 
-  ADD_TEST (test_euler_quaternion, 0, 0);
+  ADD_TEST (test_euler_quaternion, 0, TEST_KNOWN_FAILURE);
   ADD_TEST (test_color_hsl, 0, 0);
 
   ADD_TEST (test_fence, TEST_REQUIREMENT_FENCE, 0);