4. Rotating an actor
Prev | Chapter 5. Animations | Next

## 4. Rotating an actor

### 4.1. Problem

You want to animate rotation of an actor. Some example cases where you might want to do this:

- To rotate an image so it's the right way up for viewing.

- To make actors more or less prominent, rotating them towards or away from the view point.

- To turn an actor "around" and display different UI elements "behind" it.

### 4.2. Solution

Animate one of the `rotation-angle-(x|y|z)` properties of the actor.

The most "obvious" (and probably most commonly used) rotation is in the z axis (parallel to the 2D surface of the UI). The other rotation axes (x and y) are less obvious, as they rotate the actor in the depth dimension, "away from" or "towards" the view point.

Examples of each type of rotation are given below. While the examples use implicit animations, it is also possible to use ClutterAnimator and ClutterState to animate rotations: see the full example at the end of this recipe for some ClutterState code.

### Note

I've added an inaccurate (but hopefully useful) metaphor to each rotation axis ("wheel", "letter box", "door"), to make it easier to remember the effect you get from animating in that axis (and when the rotation center is inside the actor).

Rotating on the z axis ("wheel")

    clutter_actor_animate (actor,
                       CLUTTER_LINEAR,            /* easing mode */
                       1000,                      /* duration in milliseconds */
                       "rotation-angle-z", 90.0,  /* target rotation angle in degrees */
                       NULL);

The above code animating a texture:

By default, the center of the rotation is derived from the anchor point of the actor; unless you've changed the anchor point, the default is the top-left corner of the actor. See the Discussion section below for more about setting the rotation center.

### Note

An animated rotation moves an actor to the specified rotation angle; it does not increment or decrement the actor's current rotation angle by the amount specified.

Rotating on the `x` axis ("letter box")

    clutter_actor_animate (actor,
                       CLUTTER_LINEAR,
                       1000,
                       "rotation-angle-x", -45.0,
                       NULL);

The above code animating a texture:

Notice how the texture rotates away from the view point, and also how perspective effects are applied (as the actor is rotating "into" the depth dimension).

Rotating on the `y` axis ("door")

    clutter_actor_animate (actor,
                       CLUTTER_LINEAR,
                       1000,
                       "rotation-angle-y", 45.0,
                       NULL);

The above code animating a texture:

Again, the rotation is into the depth dimension, so you get perspective effects.

### 4.3. Discussion

It can sometimes be difficult to predict exactly how a particular rotation animation will appear when applied. Often the only way to find out is to experiment. However, the sections below outline some of the most common factors which affect animated rotations, with the aim of minimising the experimentation you need to do.

#### 4.3.1. Setting the rotation center for an animation

The examples in the previous section used the default center of rotation for each axis. However, it is possible to change the rotation center for an axis, in turn changing the appearance of the animation.

### Note

Rotation center coordinates are relative to the actor's coordinates, not to the coordinates of the actor's container or the stage.

##### 4.3.1.1. Setting a rotation center inside an actor

You can set the center for rotation on the x or y axes like this:

    /*
    * only required for y axis rotation;
    * here set to the mid point of the actor's y axis
    */
    gfloat x_center = clutter_actor_get_height (actor) * 0.5;

    /*
    * only required for x axis rotation;
    * here set to the mid point of the actor's x axis
    */
    gfloat y_center = clutter_actor_get_width (actor) * 0.5;

    /*
    * depth for the rotation center: positive numbers
    * are closer to the view point, negative ones
    * are further away
    */
    gfloat z_center = 0.0;

    /* set rotation center */
    clutter_actor_set_rotation (actor,
                              CLUTTER_X_AXIS,  /* or CLUTTER_Y_AXIS */
                              0.0,             /* set the rotation to this angle */
                              x_center,
                              y_center,
                              z_center);

Because z axis rotations are more common, Clutter provides some convenience functions to set the rotation center for this axis:

    clutter_actor_set_z_rotation_from_gravity (actor,
                                             0.0,
                                             CLUTTER_GRAVITY_CENTER);

`CLUTTER_GRAVITY_CENTER` makes the center of the actor the rotation center for the z axis. See the ClutterGravity enumeration for acceptable values for this parameter.

### Note

Setting the rotation center for the z axis using gravity is recommended, as Clutter will automatically recompute the rotation center if the actor's size changes. For the x and y axes, you have to do this computation yourself if you want an actor's center of rotation to stay in the same place if it is resized.

Rotation on the x axis around an actor's center:

Rotation on the y axis around an actor's center:

Rotation on the z axis around an actor's center:

##### 4.3.1.2. Setting the rotation center outside an actor

Rather than rotating the actor around a point inside itself, the rotation center can be moved to a position outside the actor. (In the case of the z axis, any rotation center setting is outside the actor as its depth is 0.) When animated, the actor will describe an arc around the rotation center, as if it's swinging from an invisible thread.

The same code as shown above can be used to set the rotation center: just set the rotation center coordinates to negative numbers (outside the actor). However, you can't use the gravity functions if the rotation center falls outside an actor.

For example, here's a rotation to -180 degrees in the x axis, with the y rotation center set to -96 (the same as the height of the actor):

Similarly, moving the z rotation center (for a rotation in the x or y axis) will cause the actor to swing "into" or "out of" the UI. Its final apparent size may be different, as it could reach a different depth in the UI by the end of the animation.

For example, here's a rotation to -180 in the x axis, with the z rotation center set to -96 (the same as the height of the actor):

The apparent final size of the actor is reduced, as it has rotated away from the view point.

#### 4.3.2. Direction of rotation

The apparent direction of an animated rotation depends on two things:

1. Whether the angle of rotation is positive or negative.

2. The rotation of the container(s) the actor is inside.

In the case of the sign of the rotation, here's what happens for each axis and rotation angle sign (positive or negative).

Axis | Sign of rotation angle | Effect on actor
--- | --- | ---
z | + | Clockwise spin about the `x,y` center of rotation.
z | - | Anti-clockwise spin about the `x,y` center of rotation.
x | + | The top swings away from the view point and the bottom swings towards it. If y rotation center == 0, the top is fixed; if y rotation center == the actor's height, the bottom is fixed.
x | - | The bottom swings away from the view point and the top swings towards it. If y rotation center == 0, the top is fixed; if y rotation center == the actor's height, the bottom is fixed.
y | + | The right-hand side swings away from the view point and the left-hand side swings towards it. When x rotation center == 0, the left-hand side if fixed; when x rotation center == the actor's width, the right-hand side is fixed.
y | - | The right-hand side swings towards the view point and the left-hand side swings away from it. When x rotation center == 0, the left-hand side if fixed; when x rotation center == the actor's width, the right-hand side is fixed.

If an actor's container is rotated, this may affect the appearance of rotation animations applied to the actor. In particular, if an actor's container has been rotated by 180 degrees in one axis, the direction of that actor's rotation may appear reversed.

For example, the video below shows an actor being animated to 90 degrees on the z axis, then back to 0 degrees; the actor's container is then rotated by 180 degrees in the y axis; then the same rotation 90 degree rotation is applied to the actor again. Note that the first time the animation is applied, the rotation is clockwise; but the second time (as the actor is effectively "reversed"), it is anti-clockwise.

#### 4.3.3. Apparent vs. actual rotation

There is a difference between an actor's apparent rotation (how much an actor appears to be rotating, from the perspective of someone looking at the UI) and its actual rotation (how much that actor is really rotating).

For example, if you rotate an actor and its container simultaneously, each by 90 degrees in the same direction, the actor will appear to have rotated by 180 degrees by the end of the animation. However, calling the `clutter_actor_get_rotation()` function for that axis on the actor still returns a rotation of 90 degrees.

#### 4.3.4. Orientation of rotation axes

The rotation axes remain fixed in the same place on the actor regardless of its rotation, even though from the viewer's perspective they may appear to move.

For example, when rotation in the z axis is 0 degrees, the actor's x axis is horizontal (across the UI) from both the actor's and the viewer's perspective. However, if you rotate the actor by 90 degrees in the z axis, the x axis is now vertical from the viewer's perspective, but still horizontal across the actor from the actor's perspective.

### 4.4. Full example

Example 5.1. Rotating an actor around x, y, and z axes using ClutterState

    #include <clutter/clutter.h>

    #define ROTATION_ANGLE 75.0
    #define DURATION       2000

    static void
    _set_next_state (ClutterState *transitions,
                     gpointer      user_data)
    {
      const gchar *current = clutter_state_get_state (transitions);
      gchar *next_state = "start";

      if (g_strcmp0 (current, "start") == 0)
        next_state = "x-cw";
      else if (g_strcmp0 (current, "x-cw") == 0)
        next_state = "x-ccw";
      else if (g_strcmp0 (current, "x-ccw") == 0)
        next_state = "x-after";
      else if (g_strcmp0 (current, "x-after") == 0)
        next_state = "y-cw";
      else if (g_strcmp0 (current, "y-cw") == 0)
        next_state = "y-ccw";
      else if (g_strcmp0 (current, "y-ccw") == 0)
        next_state = "y-after";
      else if (g_strcmp0 (current, "y-after") == 0)
        next_state = "z-cw";
      else if (g_strcmp0 (current, "z-cw") == 0)
        next_state = "z-ccw";

      clutter_state_set_state (transitions, next_state);
    }

    int
    main (int argc, char *argv[])
    {
      ClutterActor *stage;
      ClutterActor *texture;
      ClutterState *transitions;
      GError *error = NULL;
      gfloat texture_width, texture_height;

      if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
        return 1;

      stage = clutter_stage_new ();
      g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);

      texture = clutter_texture_new ();
      clutter_actor_add_constraint (texture,
                                    clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
      clutter_actor_add_constraint (texture,
                                    clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));
      clutter_texture_set_sync_size (CLUTTER_TEXTURE (texture), TRUE);
      clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
                                     "redhand.png",
                                     &error);

      if (error != NULL)
        {
          g_error ("Problem loading image into texture - %s", error->message);
          g_error_free (error);
          return 1;
        }

      clutter_actor_get_size (texture, &texture_width, &texture_height);
      clutter_actor_set_size (stage, texture_width * 2, texture_height * 2);

      /* set all centres of rotation to the centre of the texture */
      clutter_actor_set_rotation (texture,
                                  CLUTTER_X_AXIS,
                                  0.0,
                                  texture_width * 0.5,
                                  texture_height * 0.5,
                                  0.0);
      clutter_actor_set_rotation (texture,
                                  CLUTTER_Y_AXIS,
                                  0.0,
                                  texture_width * 0.5,
                                  texture_height * 0.5,
                                  0.0);
      clutter_actor_set_z_rotation_from_gravity (texture, 0.0, CLUTTER_GRAVITY_CENTER);

      clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);

      /* set up the animations */
      transitions = clutter_state_new ();

      clutter_state_set (transitions, NULL, "start",
                         texture, "rotation-angle-x", CLUTTER_LINEAR, 0.0,
                         texture, "rotation-angle-y", CLUTTER_LINEAR, 0.0,
                         texture, "rotation-angle-z", CLUTTER_LINEAR, 0.0,
                         NULL);
      clutter_state_set (transitions, NULL, "x-cw",
                         texture, "rotation-angle-x", CLUTTER_LINEAR, ROTATION_ANGLE,
                         NULL);
      clutter_state_set (transitions, NULL, "x-ccw",
                         texture, "rotation-angle-x", CLUTTER_LINEAR, -ROTATION_ANGLE,
                         NULL);
      clutter_state_set (transitions, NULL, "x-after",
                         texture, "rotation-angle-x", CLUTTER_LINEAR, 0.0,
                         NULL);
      clutter_state_set (transitions, NULL, "y-cw",
                         texture, "rotation-angle-y", CLUTTER_LINEAR, ROTATION_ANGLE,
                         NULL);
      clutter_state_set (transitions, NULL, "y-ccw",
                         texture, "rotation-angle-y", CLUTTER_LINEAR, -ROTATION_ANGLE,
                         NULL);
      clutter_state_set (transitions, NULL, "y-after",
                         texture, "rotation-angle-y", CLUTTER_LINEAR, 0.0,
                         NULL);
      clutter_state_set (transitions, NULL, "z-cw",
                         texture, "rotation-angle-z", CLUTTER_LINEAR, ROTATION_ANGLE,
                         NULL);
      clutter_state_set (transitions, NULL, "z-ccw",
                         texture, "rotation-angle-z", CLUTTER_LINEAR, -ROTATION_ANGLE,
                         NULL);
      clutter_state_set_duration (transitions, NULL, NULL, DURATION);
      clutter_state_set_duration (transitions, "start", NULL, DURATION * 0.5);
      clutter_state_set_duration (transitions, NULL, "start", DURATION * 0.5);
      clutter_state_set_duration (transitions, NULL, "x-after", DURATION * 0.5);
      clutter_state_set_duration (transitions, NULL, "y-after", DURATION * 0.5);

      clutter_state_warp_to_state (transitions, "start");

      g_signal_connect (transitions,
                        "completed",
                        G_CALLBACK (_set_next_state),
                        NULL);

      clutter_state_set_state (transitions, "x-cw");

      clutter_actor_show (stage);

      clutter_main ();

      return 0;
    }

Prev | Up | Next
3. Fading an actor out of or into view | Home | 5. Creating complex animations with ClutterAnimator