## ClutterEffect

ClutterEffect — Base class for actor effects

## Functions

void | clutter_effect_queue_repaint ()

## Types and Values

| ClutterEffect
struct | ClutterEffectClass
enum | ClutterEffectPaintFlags

## Object Hierarchy

        GObject
        ╰── GInitiallyUnowned
            ╰── ClutterActorMeta
                ╰── ClutterEffect
                    ╰── ClutterOffscreenEffect

## Description

The ClutterEffect class provides a default type and API for creating effects for generic actors.

Effects are a ClutterActorMeta sub-class that modify the way an actor is painted in a way that is not part of the actor's implementation.

Effects should be the preferred way to affect the paint sequence of an actor without sub-classing the actor itself and overriding the `ClutterActorClass.paint()`_ virtual function.

#### Implementing a ClutterEffect

Creating a sub-class of ClutterEffect requires overriding the `ClutterEffectClass.paint()` method. The implementation of the function should look something like this:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    void effect_paint (ClutterEffect *effect, ClutterEffectPaintFlags flags)
    {
      // Set up initialisation of the paint such as binding a
      // CoglOffscreen or other operations

      // Chain to the next item in the paint sequence. This will either call
      // ‘paint’ on the next effect or just paint the actor if this is
      // the last effect.
      ClutterActor *actor =
        clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));

      clutter_actor_continue_paint (actor);

      // perform any cleanup of state, such as popping the CoglOffscreen
    }

The effect can optionally avoid calling `clutter_actor_continue_paint()` to skip any further stages of the paint sequence. This is useful for example if the effect contains a cached image of the actor. In that case it can optimise painting by avoiding the actor paint and instead painting the cached image.

The `CLUTTER_EFFECT_PAINT_ACTOR_DIRTY` flag is useful in this case. Clutter will set this flag when a redraw has been queued on the actor since it was last painted. The effect can use this information to decide if the cached image is still valid.

#### A simple ClutterEffect implementation

The example below creates two rectangles: one will be painted "behind" the actor, while another will be painted "on top" of the actor.

The `ClutterActorMetaClass.set_actor()` implementation will create the two materials used for the two different rectangles; the `ClutterEffectClass.paint()` implementation will paint the first material using `cogl_rectangle()`, before continuing and then it will paint paint the second material after.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75

    typedef struct {
      ClutterEffect parent_instance;

      CoglHandle rect_1;
      CoglHandle rect_2;
    } MyEffect;

    typedef struct _ClutterEffectClass MyEffectClass;

    G_DEFINE_TYPE (MyEffect, my_effect, CLUTTER_TYPE_EFFECT);

    static void
    my_effect_set_actor (ClutterActorMeta *meta,
                         ClutterActor     *actor)
    {
      MyEffect *self = MY_EFFECT (meta);

      // Clear the previous state //
      if (self->rect_1)
        {
          cogl_handle_unref (self->rect_1);
          self->rect_1 = NULL;
        }

      if (self->rect_2)
        {
          cogl_handle_unref (self->rect_2);
          self->rect_2 = NULL;
        }

      // Maintain a pointer to the actor
      self->actor = actor;

      // If we've been detached by the actor then we should just bail out here
      if (self->actor == NULL)
        return;

      // Create a red material
      self->rect_1 = cogl_material_new ();
      cogl_material_set_color4f (self->rect_1, 1.0, 0.0, 0.0, 1.0);

      // Create a green material
      self->rect_2 = cogl_material_new ();
      cogl_material_set_color4f (self->rect_2, 0.0, 1.0, 0.0, 1.0);
    }

    static gboolean
    my_effect_paint (ClutterEffect *effect)
    {
      MyEffect *self = MY_EFFECT (effect);
      gfloat width, height;

      clutter_actor_get_size (self->actor, &width, &height);

      // Paint the first rectangle in the upper left quadrant
      cogl_set_source (self->rect_1);
      cogl_rectangle (0, 0, width / 2, height / 2);

      // Continue to the rest of the paint sequence
      clutter_actor_continue_paint (self->actor);

      // Paint the second rectangle in the lower right quadrant
      cogl_set_source (self->rect_2);
      cogl_rectangle (width / 2, height / 2, width, height);
    }

    static void
    my_effect_class_init (MyEffectClass *klass)
    {
      ClutterActorMetaClas *meta_class = CLUTTER_ACTOR_META_CLASS (klass);

      meta_class->set_actor = my_effect_set_actor;

      klass->paint = my_effect_paint;
    }

ClutterEffect is available since Clutter 1.4

## Functions

### clutter_effect_queue_repaint ()

    void
    clutter_effect_queue_repaint (ClutterEffect *effect);

Queues a repaint of the effect. The effect can detect when the ‘paint’ method is called as a result of this function because it will not have the `CLUTTER_EFFECT_PAINT_ACTOR_DIRTY` flag set. In that case the effect is free to assume that the actor has not changed its appearance since the last time it was painted so it doesn't need to call `clutter_actor_continue_paint()` if it can draw a cached image. This is mostly intended for effects that are using a `CoglOffscreen` to redirect the actor (such as `ClutterOffscreenEffect`). In that case the effect can save a bit of rendering time by painting the cached texture without causing the entire actor to be painted.

This function can be used by effects that have their own animatable parameters. For example, an effect which adds a varying degree of a red tint to an actor by redirecting it through a CoglOffscreen might have a property to specify the level of tint. When this value changes, the underlying actor doesn't need to be redrawn so the effect can call `clutter_effect_queue_repaint()` to make sure the effect is repainted.

Note however that modifying the position of the parent of an actor may change the appearance of the actor because its transformation matrix would change. In this case a redraw wouldn't be queued on the actor itself so the `CLUTTER_EFFECT_PAINT_ACTOR_DIRTY` would still not be set. The effect can detect this case by keeping track of the last modelview matrix that was used to render the actor and veryifying that it remains the same in the next paint.

Any other effects that are layered on top of the passed in effect will still be passed the `CLUTTER_EFFECT_PAINT_ACTOR_DIRTY` flag. If anything queues a redraw on the actor without specifying an effect or with an effect that is lower in the chain of effects than this one then that will override this call. In that case this effect will instead be called with the `CLUTTER_EFFECT_PAINT_ACTOR_DIRTY` flag set.

#### Parameters

effect | A ClutterEffect which needs redrawing |

Since: 1.8

## Types and Values

### ClutterEffect

    typedef struct _ClutterEffect ClutterEffect;

The ClutterEffect structure contains only private data and should be accessed using the provided API

Since: 1.4

### struct ClutterEffectClass

    struct ClutterEffectClass {
      gboolean (* pre_paint)        (ClutterEffect           *effect);
      void     (* post_paint)       (ClutterEffect           *effect);

      gboolean (* get_paint_volume) (ClutterEffect           *effect,
                                     ClutterPaintVolume      *volume);

      void     (* paint)            (ClutterEffect           *effect,
                                     ClutterEffectPaintFlags  flags);
      void     (* pick)             (ClutterEffect           *effect,
                                     ClutterEffectPaintFlags  flags);
    };

The ClutterEffectClass structure contains only private data

#### Members

`pre_paint` () | virtual function |
`post_paint` () | virtual function |
`get_paint_volume` () | virtual function |
`paint` () | virtual function |
`pick` () | virtual function |

Since: 1.4

### enum ClutterEffectPaintFlags

Flags passed to the ‘paint’ or ‘pick’ method of ClutterEffect.

#### Members

CLUTTER_EFFECT_PAINT_ACTOR_DIRTY | The actor or one of its children has queued a redraw before this paint. This implies that the effect should call `clutter_actor_continue_paint()` to chain to the next effect and can not cache any results from a previous paint. |