#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include <clutter/clutter.h>
typedef struct _FooActor FooActor;
typedef struct _FooActorClass FooActorClass;
struct _FooActorClass
{
ClutterActorClass parent_class;
};
struct _FooActor
{
ClutterActor parent;
guint8 last_paint_opacity;
int paint_count;
};
typedef struct
{
ClutterActor *stage;
FooActor *foo_actor;
ClutterActor *parent_container;
ClutterActor *container;
ClutterActor *child;
ClutterActor *unrelated_actor;
gboolean was_painted;
} Data;
GType foo_actor_get_type (void) G_GNUC_CONST;
G_DEFINE_TYPE (FooActor, foo_actor, CLUTTER_TYPE_ACTOR);
static gboolean group_has_overlaps;
static void
foo_actor_paint (ClutterActor *actor)
{
FooActor *foo_actor = (FooActor *) actor;
ClutterActorBox allocation;
foo_actor->last_paint_opacity = clutter_actor_get_paint_opacity (actor);
foo_actor->paint_count++;
clutter_actor_get_allocation_box (actor, &allocation);
/* Paint a red rectangle with the right opacity */
cogl_set_source_color4ub (255,
0,
0,
foo_actor->last_paint_opacity);
cogl_rectangle (allocation.x1,
allocation.y1,
allocation.x2,
allocation.y2);
}
static gboolean
foo_actor_get_paint_volume (ClutterActor *actor,
ClutterPaintVolume *volume)
{
return clutter_paint_volume_set_from_allocation (volume, actor);
}
static gboolean
foo_actor_has_overlaps (ClutterActor *actor)
{
return FALSE;
}
static void
foo_actor_class_init (FooActorClass *klass)
{
ClutterActorClass *actor_class = (ClutterActorClass *) klass;
actor_class->paint = foo_actor_paint;
actor_class->get_paint_volume = foo_actor_get_paint_volume;
actor_class->has_overlaps = foo_actor_has_overlaps;
}
static void
foo_actor_init (FooActor *self)
{
}
typedef struct _FooGroup FooGroup;
typedef struct _FooGroupClass FooGroupClass;
struct _FooGroupClass
{
ClutterActorClass parent_class;
};
struct _FooGroup
{
ClutterActor parent;
};
GType foo_group_get_type (void);
G_DEFINE_TYPE (FooGroup, foo_group, CLUTTER_TYPE_ACTOR)
static gboolean
foo_group_has_overlaps (ClutterActor *actor)
{
return group_has_overlaps;
}
static void
foo_group_class_init (FooGroupClass *klass)
{
ClutterActorClass *actor_class = (ClutterActorClass *) klass;
actor_class->has_overlaps = foo_group_has_overlaps;
}
static void
foo_group_init (FooGroup *self)
{
}
static void
verify_results (Data *data,
guint8 expected_color_red,
guint8 expected_color_green,
guint8 expected_color_blue,
int expected_paint_count,
int expected_paint_opacity)
{
guchar *pixel;
data->foo_actor->paint_count = 0;
/* Read a pixel at the center of the to determine what color it
painted. This should cause a redraw */
pixel = clutter_stage_read_pixels (CLUTTER_STAGE (data->stage),
50, 50, /* x/y */
1, 1 /* width/height */);
g_assert_cmpint (expected_paint_count, ==, data->foo_actor->paint_count);
g_assert_cmpint (expected_paint_opacity,
==,
data->foo_actor->last_paint_opacity);
g_assert_cmpint (ABS ((int) expected_color_red - (int) pixel[0]), <=, 2);
g_assert_cmpint (ABS ((int) expected_color_green - (int) pixel[1]), <=, 2);
g_assert_cmpint (ABS ((int) expected_color_blue - (int) pixel[2]), <=, 2);
g_free (pixel);
}
static void
verify_redraw (Data *data, int expected_paint_count)
{
GMainLoop *main_loop = g_main_loop_new (NULL, TRUE);
guint paint_handler;
paint_handler = g_signal_connect_data (data->stage,
"paint",
G_CALLBACK (g_main_loop_quit),
main_loop,
NULL,
G_CONNECT_SWAPPED | G_CONNECT_AFTER);
/* Queue a redraw on the stage */
clutter_actor_queue_redraw (data->stage);
data->foo_actor->paint_count = 0;
/* Wait for it to paint */
g_main_loop_run (main_loop);
g_signal_handler_disconnect (data->stage, paint_handler);
g_assert_cmpint (data->foo_actor->paint_count, ==, expected_paint_count);
}
static gboolean
run_verify (gpointer user_data)
{
Data *data = user_data;
group_has_overlaps = FALSE;
/* By default the actor shouldn't be redirected so the redraw should
cause the actor to be painted */
verify_results (data,
255, 0, 0,
1,
255);
/* Make the actor semi-transparent and verify the paint opacity */
clutter_actor_set_opacity (data->container, 127);
verify_results (data,
255, 127, 127,
1,
127);
/* With automatic redirect for opacity it shouldn't redirect if
* has_overlaps returns FALSE; */
clutter_actor_set_offscreen_redirect
(data->container, CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY);
verify_results (data,
255, 127, 127,
1,
127);
/* We do a double check here to verify that the actor wasn't cached
* during the last check. If it was cached then this check wouldn't
* result in any foo-actor re-paint. */
verify_results (data,
255, 127, 127,
1,
127);
/* With automatic redirect for opacity it should redirect if
* has_overlaps returns TRUE.
* The first paint will still cause the actor to draw because
* it needs to fill the cache first. It should be painted with full
* opacity */
group_has_overlaps = TRUE;
verify_results (data,
255, 127, 127,
1,
255);
/* The second time the actor is painted it should be cached */
verify_results (data,
255, 127, 127,
0,
255);
/* We should be able to change the opacity without causing the actor
to redraw */
clutter_actor_set_opacity (data->container, 64);
verify_results (data,
255, 191, 191,
0,
255);
/* Changing it back to fully opaque should cause it not to go
through the FBO so it will draw */
clutter_actor_set_opacity (data->container, 255);
verify_results (data,
255, 0, 0,
1,
255);
/* Tell it to always redirect through the FBO. This should cause a
paint of the actor because the last draw didn't go through the
FBO */
clutter_actor_set_offscreen_redirect (data->container,
CLUTTER_OFFSCREEN_REDIRECT_ALWAYS);
verify_results (data,
255, 0, 0,
1,
255);
/* We should be able to change the opacity without causing the actor
to redraw */
clutter_actor_set_opacity (data->container, 64);
verify_results (data,
255, 191, 191,
0,
255);
/* Even changing it back to fully opaque shouldn't cause a redraw */
clutter_actor_set_opacity (data->container, 255);
verify_results (data,
255, 0, 0,
0,
255);
/* Queueing a redraw on the actor should cause a redraw */
clutter_actor_queue_redraw (data->container);
verify_redraw (data, 1);
/* Queueing a redraw on a child should cause a redraw */
clutter_actor_queue_redraw (data->child);
verify_redraw (data, 1);
/* Modifying the transformation on the parent should cause a
redraw */
clutter_actor_set_anchor_point (data->parent_container, 0, 1);
verify_redraw (data, 1);
/* Redrawing an unrelated actor shouldn't cause a redraw */
clutter_actor_set_position (data->unrelated_actor, 0, 1);
verify_redraw (data, 0);
data->was_painted = TRUE;
return G_SOURCE_REMOVE;
}
static void
actor_offscreen_redirect (void)
{
Data data;
if (!cogl_features_available (COGL_FEATURE_OFFSCREEN))
return;
data.stage = clutter_test_get_stage ();
data.parent_container = clutter_actor_new ();
data.container = g_object_new (foo_group_get_type (), NULL);
data.foo_actor = g_object_new (foo_actor_get_type (), NULL);
clutter_actor_set_size (CLUTTER_ACTOR (data.foo_actor), 100, 100);
clutter_actor_add_child (data.container, CLUTTER_ACTOR (data.foo_actor));
clutter_actor_add_child (data.parent_container, data.container);
clutter_actor_add_child (data.stage, data.parent_container);
data.child = clutter_actor_new ();
clutter_actor_set_size (data.child, 1, 1);
clutter_actor_add_child (data.container, data.child);
data.unrelated_actor = clutter_actor_new ();
clutter_actor_set_size (data.child, 1, 1);
clutter_actor_add_child (data.stage, data.unrelated_actor);
clutter_actor_show (data.stage);
clutter_threads_add_repaint_func_full (CLUTTER_REPAINT_FLAGS_POST_PAINT,
run_verify,
&data,
NULL);
while (!data.was_painted)
g_main_context_iteration (NULL, FALSE);
}
CLUTTER_TEST_SUITE (
CLUTTER_TEST_UNIT ("/actor/offscreen/redirect", actor_offscreen_redirect)
)