[mutter/gbsneto/graphene-matrix: 72/87] clutter/actor: Use graphene APIs

[Georges Basile Stavracas Neto <gbsneto src gnome org>]

commit 9291140fa520011f4543eb127efb054c629e7d5d
Author: Georges Basile Stavracas Neto <georges stavracas gmail com>
Date:   Fri Sep 11 17:27:19 2020 -0300

    clutter/actor: Use graphene APIs
    
    ClutterActor is a particularly heavy user of matrices, and
    switching to graphene_matrix_* APIs means we had to change
    the order of operations due to left-hand vs right-hand
    differences.
    
    When applying the actor transform, there are 2 main branches
    that can be followed: the default transforms, and when a
    custom transform is set.
    
    To facilitate review, here's the table that I've made to
    guide myself:
    
    +--------------- Case 1: Default Transforms --------------+
    |        CoglMatrix          |      graphene_matrix_t     |
    +----------------------------+----------------------------+
    | multiply (child transform) | translate (-pivot)         |
    | translate (allocation)¹    | rotate_x (angle)           |
    | translate (pivot)¹         | rotate_y (angle)           |
    | translate (translation)¹   | rotate_z (angle)           |
    | scale (sx, sy, sz)         | scale (sx, sy, sz)         |
    | rotate_z (angle)           | translate (translation)¹   |
    | rotate_y (angle)           | translate (pivot)¹         |
    | rotate_x (angle)           | translate (allocation)¹    |
    | translate (-pivot)         | multiply (child transform) |
    +----------------------------+----------------------------+
    
    ¹ - these 3 translations are simplified as a single call
        to translate(allocation + pivot + translation)
    
    +---------------- Case 2: Custom Transform ---------------+
    |        CoglMatrix          |      graphene_matrix_t     |
    +----------------------------+----------------------------+
    | multiply (child transform) | translate (-pivot)         |
    | translate (allocation)²    | multiply (transform)       |
    | translate (pivot)²         | translate (pivot)²         |
    | multiply (transform)       | translate (allocation)²    |
    | translate (-pivot)         | multiply (child transform) |
    +----------------------------+----------------------------+
    
    ² - likewise, these 2 translations are simplified as a
        single call to translate(allocation + pivot)
    
    https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1439

 clutter/clutter/clutter-actor.c | 113 +++++++++++++++++++---------------------
 1 file changed, 55 insertions(+), 58 deletions(-)
---
diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c
index 95da5d2437..d7ca20e277 100644
--- a/clutter/clutter/clutter-actor.c
+++ b/clutter/clutter/clutter-actor.c
@@ -1268,9 +1268,9 @@ _clutter_actor_transform_local_box_to_stage (ClutterActor          *self,
   if (!stage_priv->has_inverse_transform)
     return FALSE;
   cogl_framebuffer_get_modelview_matrix (fb, &modelview);
-  cogl_matrix_multiply (&transform_to_stage,
-                        &stage_priv->inverse_transform,
-                        &modelview);
+  graphene_matrix_multiply (&modelview,
+                            &stage_priv->inverse_transform,
+                            &transform_to_stage);
 
   vertices[0].x = box->x1;
   vertices[0].y = box->y1;
@@ -2975,7 +2975,7 @@ _clutter_actor_get_relative_transformation_matrix (ClutterActor      *self,
                                                    ClutterActor      *ancestor,
                                                    graphene_matrix_t *matrix)
 {
-  cogl_matrix_init_identity (matrix);
+  graphene_matrix_init_identity (matrix);
 
   _clutter_actor_apply_relative_transformation_matrix (self, ancestor, matrix);
 }
@@ -3065,6 +3065,7 @@ clutter_actor_real_apply_transform (ClutterActor      *self,
 {
   ClutterActorPrivate *priv = self->priv;
   const ClutterTransformInfo *info;
+  graphene_point3d_t p;
   float pivot_x = 0.f, pivot_y = 0.f;
 
   info = _clutter_actor_get_transform_info_or_defaults (self);
@@ -3086,72 +3087,66 @@ clutter_actor_real_apply_transform (ClutterActor      *self,
                 priv->allocation.x1 + pivot_x + info->translation.x,
                 priv->allocation.y1 + pivot_y + info->translation.y);
 
-  /* we apply the :child-transform from the parent actor, if we have one */
-  if (priv->parent != NULL)
+  /* roll back the pivot translation */
+  if (pivot_x != 0.f || pivot_y != 0.f || info->pivot_z != 0.f)
     {
-      const ClutterTransformInfo *parent_info;
-
-      parent_info = _clutter_actor_get_transform_info_or_defaults (priv->parent);
-      cogl_matrix_init_from_matrix (matrix, &(parent_info->child_transform));
+      graphene_point3d_init (&p, -pivot_x, -pivot_y, -info->pivot_z);
+      graphene_matrix_translate (matrix, &p);
     }
-  else
-    cogl_matrix_init_identity (matrix);
 
   /* if we have an overriding transformation, we use that, and get out */
   if (info->transform_set)
     {
+      graphene_matrix_multiply (matrix, &info->transform, matrix);
+
       /* we still need to apply the :allocation's origin and :pivot-point
        * translations, since :transform is relative to the actor's coordinate
        * space, and to the pivot point
        */
-      cogl_matrix_translate (matrix,
+      graphene_point3d_init (&p,
                              priv->allocation.x1 + pivot_x,
                              priv->allocation.y1 + pivot_y,
                              info->pivot_z);
-      cogl_matrix_multiply (matrix, matrix, &info->transform);
-      goto roll_back_pivot;
+      graphene_matrix_translate (matrix, &p);
+      goto roll_back;
     }
 
+  if (info->rx_angle)
+    graphene_matrix_rotate (matrix, info->rx_angle, graphene_vec3_x_axis ());
+
+  if (info->ry_angle)
+    graphene_matrix_rotate (matrix, info->ry_angle, graphene_vec3_y_axis ());
+
+  if (info->rz_angle)
+    graphene_matrix_rotate (matrix, info->rz_angle, graphene_vec3_z_axis ());
+
+  if (info->scale_x != 1.0 || info->scale_y != 1.0 || info->scale_z != 1.0)
+    graphene_matrix_scale (matrix, info->scale_x, info->scale_y, info->scale_z);
+
   /* 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 (matrix,
+  graphene_point3d_init (&p,
                          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);
+  graphene_matrix_translate (matrix, &p);
 
-  /* 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)
-    cogl_matrix_scale (matrix, info->scale_x, info->scale_y, info->scale_z);
-
-  if (info->rz_angle)
-    cogl_matrix_rotate (matrix, info->rz_angle, 0, 0, 1.0);
-
-  if (info->ry_angle)
-    cogl_matrix_rotate (matrix, info->ry_angle, 0, 1.0, 0);
-
-  if (info->rx_angle)
-    cogl_matrix_rotate (matrix, info->rx_angle, 1.0, 0, 0);
+roll_back:
+  /* we apply the :child-transform from the parent actor, if we have one */
+  if (priv->parent != NULL)
+    {
+      const ClutterTransformInfo *parent_info;
 
-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 (matrix, -pivot_x, -pivot_y, -info->pivot_z);
+      parent_info = _clutter_actor_get_transform_info_or_defaults (priv->parent);
+      graphene_matrix_multiply (matrix, &parent_info->child_transform, matrix);
+    }
 }
 
 /* Applies the transforms associated with this actor to the given
  * matrix. */
+
 static void
 ensure_valid_actor_transform (ClutterActor *actor)
 {
@@ -3160,6 +3155,8 @@ ensure_valid_actor_transform (ClutterActor *actor)
   if (priv->transform_valid)
     return;
 
+  graphene_matrix_init_identity (&priv->transform);
+
   CLUTTER_ACTOR_GET_CLASS (actor)->apply_transform (actor, &priv->transform);
   priv->has_inverse_transform =
     cogl_graphene_matrix_get_inverse (&priv->transform,
@@ -3175,7 +3172,7 @@ _clutter_actor_apply_modelview_transform (ClutterActor      *self,
   ClutterActorPrivate *priv = self->priv;
 
   ensure_valid_actor_transform (self);
-  cogl_matrix_multiply (matrix, matrix, &priv->transform);
+  graphene_matrix_multiply (&priv->transform, matrix, matrix);
 }
 
 /*
@@ -3201,7 +3198,7 @@ _clutter_actor_apply_modelview_transform (ClutterActor      *self,
  *
  * This function doesn't initialize the given @matrix, it simply
  * multiplies the requested transformation matrix with the existing contents of
- * @matrix. You can use cogl_matrix_init_identity() to initialize the @matrix
+ * @matrix. You can use graphene_matrix_init_identity() to initialize the @matrix
  * before calling this function, or you can use
  * clutter_actor_get_relative_transformation_matrix() instead.
  */
@@ -3839,7 +3836,7 @@ clutter_actor_paint (ClutterActor        *self,
 
       clutter_actor_get_transform (self, &transform);
 
-      if (!cogl_matrix_is_identity (&transform))
+      if (!graphene_matrix_is_identity (&transform))
         {
           transform_node = clutter_transform_node_new (&transform);
           clutter_paint_node_add_child (transform_node, root_node);
@@ -3858,7 +3855,7 @@ clutter_actor_paint (ClutterActor        *self,
           _clutter_actor_get_relative_transformation_matrix (self, NULL,
                                                              &expected_matrix);
 
-          if (!cogl_matrix_equal (&transform, &expected_matrix))
+          if (!graphene_matrix_equal_fast (&transform, &expected_matrix))
             {
               GString *buf = g_string_sized_new (1024);
               ClutterActor *parent;
@@ -4461,8 +4458,8 @@ get_default_transform_info (void)
 
   if (G_UNLIKELY (g_once_init_enter (&initialized)))
     {
-      cogl_matrix_init_identity (&default_transform_info.transform);
-      cogl_matrix_init_identity (&default_transform_info.child_transform);
+      graphene_matrix_init_identity (&default_transform_info.transform);
+      graphene_matrix_init_identity (&default_transform_info.child_transform);
       g_once_init_leave (&initialized, TRUE);
     }
 
@@ -14817,7 +14814,7 @@ clutter_actor_set_transform_internal (ClutterActor            *self,
   was_set = info->transform_set;
 
   info->transform = *transform;
-  info->transform_set = !cogl_matrix_is_identity (&info->transform);
+  info->transform_set = !graphene_matrix_is_identity (&info->transform);
 
   transform_changed (self);
 
@@ -14855,9 +14852,9 @@ clutter_actor_set_transform (ClutterActor            *self,
   info = _clutter_actor_get_transform_info_or_defaults (self);
 
   if (transform != NULL)
-    cogl_matrix_init_from_matrix (&new_transform, transform);
+    graphene_matrix_init_from_matrix (&new_transform, transform);
   else
-    cogl_matrix_init_identity (&new_transform);
+    graphene_matrix_init_identity (&new_transform);
 
   _clutter_actor_create_transition (self, obj_props[PROP_TRANSFORM],
                                     &info->transform,
@@ -14880,7 +14877,7 @@ clutter_actor_get_transform (ClutterActor      *self,
   g_return_if_fail (CLUTTER_IS_ACTOR (self));
   g_return_if_fail (transform != NULL);
 
-  cogl_matrix_init_identity (transform);
+  graphene_matrix_init_identity (transform);
   _clutter_actor_apply_modelview_transform (self, transform);
 }
 
@@ -19423,10 +19420,10 @@ clutter_actor_set_child_transform_internal (ClutterActor            *self,
   GObject *obj;
   gboolean was_set = info->child_transform_set;
 
-  cogl_matrix_init_from_matrix (&info->child_transform, transform);
+  graphene_matrix_init_from_matrix (&info->child_transform, transform);
 
   /* if it's the identity matrix, we need to toggle the boolean flag */
-  info->child_transform_set = !cogl_matrix_is_identity (transform);
+  info->child_transform_set = !graphene_matrix_is_identity (transform);
 
   /* we need to reset the transform_valid flag on each child */
   clutter_actor_iter_init (&iter, self);
@@ -19469,9 +19466,9 @@ clutter_actor_set_child_transform (ClutterActor            *self,
   info = _clutter_actor_get_transform_info_or_defaults (self);
 
   if (transform != NULL)
-    cogl_matrix_init_from_matrix (&new_transform, transform);
+    graphene_matrix_init_from_matrix (&new_transform, transform);
   else
-    cogl_matrix_init_identity (&new_transform);
+    graphene_matrix_init_identity (&new_transform);
 
   _clutter_actor_create_transition (self, obj_props[PROP_CHILD_TRANSFORM],
                                     &info->child_transform,
@@ -19501,9 +19498,9 @@ clutter_actor_get_child_transform (ClutterActor      *self,
   info = _clutter_actor_get_transform_info_or_defaults (self);
 
   if (info->child_transform_set)
-    cogl_matrix_init_from_matrix (transform, &info->child_transform);
+    graphene_matrix_init_from_matrix (transform, &info->child_transform);
   else
-    cogl_matrix_init_identity (transform);
+    graphene_matrix_init_identity (transform);
 }
 
 static void