sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/tests/interactive/test-actor-clone.c

289 lines
7.3 KiB
C
Raw Normal View History

Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
#include <clutter/clutter.h>
#include <math.h>
#include <errno.h>
#include <stdlib.h>
#include <glib.h>
#include <gmodule.h>
#define NHANDS 6
typedef struct SuperOH
{
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
ClutterActor **hand, *bgtex;
ClutterActor *real_hand;
ClutterActor *group;
ClutterActor *stage;
gint stage_width;
gint stage_height;
gfloat radius;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
ClutterBehaviour *scaler_1;
ClutterBehaviour *scaler_2;
ClutterTimeline *timeline;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
} SuperOH;
static gint n_hands = NHANDS;
static GOptionEntry super_oh_entries[] = {
{
"num-hands", 'n',
0,
G_OPTION_ARG_INT, &n_hands,
"Number of hands", "HANDS"
},
{ NULL }
};
/* input handler */
static gboolean
input_cb (ClutterActor *stage,
ClutterEvent *event,
gpointer data)
{
SuperOH *oh = data;
if (event->type == CLUTTER_BUTTON_PRESS)
{
ClutterButtonEvent *button_event;
ClutterActor *e;
gint x, y;
clutter_event_get_coords (event, &x, &y);
button_event = (ClutterButtonEvent *) event;
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
g_print ("*** button press event (button:%d) at %d, %d ***\n",
button_event->button,
x, y);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
e = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (stage), x, y);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
/* only allow hiding the clones */
if (e && CLUTTER_IS_CLONE (e))
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
clutter_actor_hide (e);
return TRUE;
}
}
else if (event->type == CLUTTER_KEY_RELEASE)
{
ClutterKeyEvent *kev = (ClutterKeyEvent *) event;
g_print ("*** key press event (key:%c) ***\n",
clutter_key_event_symbol (kev));
if (clutter_key_event_symbol (kev) == CLUTTER_q)
{
clutter_main_quit ();
return TRUE;
}
else if (clutter_key_event_symbol (kev) == CLUTTER_r)
{
gint i;
for (i = 0; i < n_hands; i++)
clutter_actor_show (oh->hand[i]);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_actor_show (oh->real_hand);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
return TRUE;
}
}
return FALSE;
}
/* Timeline handler */
static void
frame_cb (ClutterTimeline *timeline,
gint frame_num,
gpointer data)
{
SuperOH *oh = data;
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
gint i;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* Rotate everything clockwise about stage center*/
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_actor_set_rotation (oh->group,
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
CLUTTER_Z_AXIS,
frame_num,
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh->stage_width / 2,
oh->stage_height / 2,
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
0);
for (i = 0; i < n_hands; i++)
{
gdouble scale_x, scale_y;
clutter_actor_get_scale (oh->hand[i], &scale_x, &scale_y);
/* Rotate each hand around there centers - to get this we need
* to take into account any scaling.
*/
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_actor_set_rotation (oh->hand[i],
CLUTTER_Z_AXIS,
-6.0 * frame_num,
0, 0, 0);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
}
Merge branch 'generic-actor-clone' * generic-actor-clone: Remove CloneTexture from the API [tests] Clean up the Clone interactive test Rename ActorClone to Clone/2 Rename ActorClone to Clone/1 Improves the unit test to verify more awkward scaling and some corresponding fixes Implements a generic ClutterActorClone that doesn't need fbos.
2009-01-27 16:12:30 +00:00
static gdouble
my_sine_wave (ClutterAlpha *alpha,
gpointer dummy G_GNUC_UNUSED)
{
ClutterTimeline *timeline = clutter_alpha_get_timeline (alpha);
gdouble progress = clutter_timeline_get_progress (timeline);
return sin (progress * G_PI);
}
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
G_MODULE_EXPORT int
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
test_actor_clone_main (int argc, char *argv[])
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
ClutterAlpha *alpha;
ClutterActor *stage;
ClutterColor stage_color = { 0x61, 0x64, 0x8c, 0xff };
SuperOH *oh;
gint i;
GError *error;
ClutterActor *real_hand, *tmp;
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
ClutterColor clr = { 0xff, 0xff, 0x00, 0xff };
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
error = NULL;
clutter_init_with_args (&argc, &argv,
NULL,
super_oh_entries,
NULL,
&error);
if (error)
{
g_warning ("Unable to initialise Clutter:\n%s",
error->message);
g_error_free (error);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
return EXIT_FAILURE;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 800, 600);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_stage_set_title (CLUTTER_STAGE (stage), "Clone Test");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh = g_new (SuperOH, 1);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* Create a timeline to manage animation */
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh->timeline = clutter_timeline_new (360, 60);
clutter_timeline_set_loop (oh->timeline, TRUE);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* fire a callback for frame change */
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
g_signal_connect (oh->timeline, "new-frame", G_CALLBACK (frame_cb), oh);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* Set up some behaviours to handle scaling */
Merge branch 'generic-actor-clone' * generic-actor-clone: Remove CloneTexture from the API [tests] Clean up the Clone interactive test Rename ActorClone to Clone/2 Rename ActorClone to Clone/1 Improves the unit test to verify more awkward scaling and some corresponding fixes Implements a generic ClutterActorClone that doesn't need fbos.
2009-01-27 16:12:30 +00:00
alpha = clutter_alpha_new_with_func (oh->timeline, my_sine_wave, NULL, NULL);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh->scaler_1 = clutter_behaviour_scale_new (alpha, 0.5, 0.5, 1.0, 1.0);
oh->scaler_2 = clutter_behaviour_scale_new (alpha, 1.0, 1.0, 0.5, 0.5);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
tmp = clutter_texture_new_from_file ("redhand.png", &error);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
if (tmp == NULL)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
g_error ("image load failed: %s", error->message);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
return EXIT_FAILURE;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
clutter_actor_set_size (tmp, 300, 500);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
real_hand = clutter_group_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (real_hand), tmp);
tmp = clutter_rectangle_new_with_color (&clr);
clutter_actor_set_size (tmp, 100, 100);
clutter_container_add_actor (CLUTTER_CONTAINER (real_hand), tmp);
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
clutter_actor_set_scale (real_hand, 0.5, 0.5);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh->real_hand = real_hand;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* Now stick the group we want to clone into another group with a custom
* opacity to verify that the clones don't traverse this parent when
* calculating their opacity. */
tmp = clutter_group_new ();
clutter_actor_set_opacity (tmp, 0x80);
clutter_container_add_actor (CLUTTER_CONTAINER (tmp), real_hand);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), tmp);
/* create a new group to hold multiple actors in a group */
oh->group = clutter_group_new();
oh->hand = g_new (ClutterActor*, n_hands);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
oh->stage_width = clutter_actor_get_width (stage);
oh->stage_height = clutter_actor_get_height (stage);
oh->radius = (oh->stage_width + oh->stage_height)
/ n_hands;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
for (i = 0; i < n_hands; i++)
{
gint x, y, w, h;
/* Create a texture from file, then clone in to same resources */
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
oh->hand[i] = clutter_clone_new (real_hand);
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
clutter_actor_set_size (oh->hand[i], 200, 213);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* Place around a circle */
w = clutter_actor_get_width (oh->hand[0]);
h = clutter_actor_get_height (oh->hand[0]);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
x = oh->stage_width / 2
+ oh->radius
* cos (i * G_PI / (n_hands / 2))
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
- w / 2;
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
y = oh->stage_height / 2
+ oh->radius
* sin (i * G_PI / (n_hands / 2))
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
- h / 2;
clutter_actor_set_position (oh->hand[i], x, y);
clutter_actor_move_anchor_point_from_gravity (oh->hand[i],
CLUTTER_GRAVITY_CENTER);
/* Add to our group group */
clutter_container_add_actor (CLUTTER_CONTAINER (oh->group), oh->hand[i]);
if (i % 2)
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_behaviour_apply (oh->scaler_1, oh->hand[i]);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
else
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_behaviour_apply (oh->scaler_2, oh->hand[i]);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
/* Add the group to the stage */
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (stage), oh->group);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
/* Show everying */
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
clutter_actor_show (stage);
g_signal_connect (stage, "button-press-event",
G_CALLBACK (input_cb),
oh);
g_signal_connect (stage, "key-release-event",
G_CALLBACK (input_cb),
oh);
/* and start it */
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
clutter_timeline_start (oh->timeline);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
clutter_main ();
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
/* clean up */
g_object_unref (oh->scaler_1);
g_object_unref (oh->scaler_2);
g_object_unref (oh->timeline);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
g_free (oh->hand);
g_free (oh);
[tests] Clean up the Clone interactive test Do not assume the default stage, and store more data inside the "application" structure that gets passed around instead of relying on macros.
2009-01-27 14:36:12 +00:00
return EXIT_SUCCESS;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
Copy permalink