brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
19f112f9bc
mutter/tests/interactive/test-actor-clone.c

286 lines
7.2 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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 }
};
static gboolean
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
on_button_press_event (ClutterActor *actor,
ClutterEvent *event,
SuperOH *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 11:51:03 -05:00
{
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
gfloat 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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
clutter_event_get_coords (event, &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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
g_print ("*** button press event (button:%d) at %.2f, %.2f ***\n",
clutter_event_get_button (event),
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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
clutter_actor_hide (actor);
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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
return 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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
static gboolean
input_cb (ClutterActor *stage,
ClutterEvent *event,
gpointer data)
{
SuperOH *oh = data;
if (event->type == CLUTTER_KEY_RELEASE)
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 11:51:03 -05:00
{
g_print ("*** key press event (key:%c) ***\n",
introspection-friendly ClutterEvent accessors ClutterEvent is not really gobject-introspection friendly because of the whole discriminated union thing. In particular, if you get a ClutterEvent in a signal handler, you probably can't access the event-type-specific fields, and you probably can't call methods like clutter_key_event_symbol() either, because you can't cast the ClutterEvent to a ClutterKeyEvent. The cleanest solution is to turn every accessor into ClutterEvent methods, accepting a ClutterEvent* and internally checking the event type. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1585
2009-06-06 10:27:37 -04:00
clutter_event_get_key_symbol (event));
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 11:51:03 -05:00
introspection-friendly ClutterEvent accessors ClutterEvent is not really gobject-introspection friendly because of the whole discriminated union thing. In particular, if you get a ClutterEvent in a signal handler, you probably can't access the event-type-specific fields, and you probably can't call methods like clutter_key_event_symbol() either, because you can't cast the ClutterEvent to a ClutterKeyEvent. The cleanest solution is to turn every accessor into ClutterEvent methods, accepting a ClutterEvent* and internally checking the event type. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1585
2009-06-06 10:27:37 -04:00
if (clutter_event_get_key_symbol (event) == CLUTTER_q)
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 11:51:03 -05:00
{
clutter_main_quit ();
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04: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 11:51:03 -05:00
return TRUE;
}
introspection-friendly ClutterEvent accessors ClutterEvent is not really gobject-introspection friendly because of the whole discriminated union thing. In particular, if you get a ClutterEvent in a signal handler, you probably can't access the event-type-specific fields, and you probably can't call methods like clutter_key_event_symbol() either, because you can't cast the ClutterEvent to a ClutterKeyEvent. The cleanest solution is to turn every accessor into ClutterEvent methods, accepting a ClutterEvent* and internally checking the event type. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1585
2009-06-06 10:27:37 -04:00
else if (clutter_event_get_key_symbol (event) == CLUTTER_r)
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 11:51:03 -05:00
{
gint i;
for (i = 0; i < n_hands; i++)
clutter_actor_show (oh->hand[i]);
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 09:36:12 -05:00
gint i;
[timeline] Remove the concept of frames from timelines Timelines no longer work in terms of a frame rate and a number of frames but instead just have a duration in milliseconds. This better matches the working of the master clock where if any timelines are running it will redraw as fast as possible rather than limiting to the lowest rated timeline. Most applications will just create animations and expect them to finish in a certain amount of time without caring about how many frames are drawn. If a frame is going to be drawn it might as well update all of the animations to some fraction of the total animation rather than rounding to the nearest whole frame. The 'frame_num' parameter of the new-frame signal is now 'msecs' which is a number of milliseconds progressed along the timeline. Applications should use clutter_timeline_get_progress instead of the frame number. Markers can now only be attached at a time value. The position is stored in milliseconds rather than at a frame number. test-timeline-smoothness and test-timeline-dup-frames have been removed because they no longer make sense.
2009-06-04 08:05:12 -04:00
float rotation = clutter_timeline_get_progress (timeline) * 360.0f;
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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05:00
CLUTTER_Z_AXIS,
[timeline] Remove the concept of frames from timelines Timelines no longer work in terms of a frame rate and a number of frames but instead just have a duration in milliseconds. This better matches the working of the master clock where if any timelines are running it will redraw as fast as possible rather than limiting to the lowest rated timeline. Most applications will just create animations and expect them to finish in a certain amount of time without caring about how many frames are drawn. If a frame is going to be drawn it might as well update all of the animations to some fraction of the total animation rather than rounding to the nearest whole frame. The 'frame_num' parameter of the new-frame signal is now 'msecs' which is a number of milliseconds progressed along the timeline. Applications should use clutter_timeline_get_progress instead of the frame number. Markers can now only be attached at a time value. The position is stored in milliseconds rather than at a frame number. test-timeline-smoothness and test-timeline-dup-frames have been removed because they no longer make sense.
2009-06-04 08:05:12 -04:00
rotation,
[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 09:36:12 -05: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 11:51:03 -05:00
0);
for (i = 0; i < n_hands; i++)
{
/* 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 09:36:12 -05:00
clutter_actor_set_rotation (oh->hand[i],
CLUTTER_Z_AXIS,
[timeline] Remove the concept of frames from timelines Timelines no longer work in terms of a frame rate and a number of frames but instead just have a duration in milliseconds. This better matches the working of the master clock where if any timelines are running it will redraw as fast as possible rather than limiting to the lowest rated timeline. Most applications will just create animations and expect them to finish in a certain amount of time without caring about how many frames are drawn. If a frame is going to be drawn it might as well update all of the animations to some fraction of the total animation rather than rounding to the nearest whole frame. The 'frame_num' parameter of the new-frame signal is now 'msecs' which is a number of milliseconds progressed along the timeline. Applications should use clutter_timeline_get_progress instead of the frame number. Markers can now only be attached at a time value. The position is stored in milliseconds rather than at a frame number. test-timeline-smoothness and test-timeline-dup-frames have been removed because they no longer make sense.
2009-06-04 08:05:12 -04:00
-6.0 * rotation,
[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 09:36:12 -05:00
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 11:51:03 -05: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 11:12:30 -05: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 11:51:03 -05: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 14:11:00 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05:00
/* Create a timeline to manage animation */
[timeline] Remove the concept of frames from timelines Timelines no longer work in terms of a frame rate and a number of frames but instead just have a duration in milliseconds. This better matches the working of the master clock where if any timelines are running it will redraw as fast as possible rather than limiting to the lowest rated timeline. Most applications will just create animations and expect them to finish in a certain amount of time without caring about how many frames are drawn. If a frame is going to be drawn it might as well update all of the animations to some fraction of the total animation rather than rounding to the nearest whole frame. The 'frame_num' parameter of the new-frame signal is now 'msecs' which is a number of milliseconds progressed along the timeline. Applications should use clutter_timeline_get_progress instead of the frame number. Markers can now only be attached at a time value. The position is stored in milliseconds rather than at a frame number. test-timeline-smoothness and test-timeline-dup-frames have been removed because they no longer make sense.
2009-06-04 08:05:12 -04:00
oh->timeline = clutter_timeline_new (6000);
[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 09:36:12 -05:00
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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 11:12:30 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 14:11:00 -05: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 09:36:12 -05: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 11:51:03 -05: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 14:11:00 -05: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 09:36:12 -05: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 11:51:03 -05: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);
[tests] Verify that Clone can paint hidden sources With the change in commit 87e4e2 painting of hidden source actors in ClutterClone was fixed. This commit changes the test-actor-clone to visually verify this.
2009-05-01 07:42:37 -04:00
/* now hide the group so that we can verify that hidden source actors
* still get painted by the Clone
*/
clutter_actor_hide (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 11:51:03 -05:00
/* 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 09:36:12 -05: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 11:51:03 -05: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 06:03:12 -05:00
oh->hand[i] = clutter_clone_new (real_hand);
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04: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 14:11:00 -05: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 11:51:03 -05:00
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
clutter_actor_set_reactive (oh->hand[i], 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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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]);
[tests] Update test-actors (and clones) The test-actors test (and its clones, test-actor-clone and test-paint-wrapper) was written a long time ago for a different API and has been tweaked to bits. We should probably have something a little bit more complicated, but at least we should not use semantics and coding patterns from Clutter 0.2, otherwise we won't be testing anything except that Clutter 0.2 worked.
2009-06-11 11:23:26 -04:00
g_signal_connect (oh->hand[i], "button-press-event",
G_CALLBACK (on_button_press_event),
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 11:51:03 -05:00
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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05:00
clutter_actor_show (stage);
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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05: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 09:36:12 -05: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 11:51:03 -05:00
}
Reference in New Issue Copy Permalink