isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 12:32:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
d8459b0a32
mutter/tests/interactive/test-depth.c

216 lines
6.9 KiB
C
Raw Normal View History

2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
#include <stdlib.h>
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 19:32:28 +00:00
#include <gmodule.h>
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
#include <clutter/clutter.h>
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
/* each time the timeline animating the label completes, swap the direction */
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
static void
timeline_completed (ClutterTimeline *timeline,
gpointer user_data)
{
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_timeline_set_direction (timeline,
!clutter_timeline_get_direction (timeline));
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
clutter_timeline_start (timeline);
}
2008-10-08 Emmanuele Bassi <ebassi@linux.intel.com> * tests/test-depth.c (raise_top), (main): Fix a shadowing with raise() from signal.h.
2008-10-08 19:50:22 +00:00
static ClutterActor *raise_actor[2];
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
static gboolean raise_no = 0;
static gboolean
raise_top (gpointer ignored)
{
2008-10-08 Emmanuele Bassi <ebassi@linux.intel.com> * tests/test-depth.c (raise_top), (main): Fix a shadowing with raise() from signal.h.
2008-10-08 19:50:22 +00:00
clutter_actor_raise_top (raise_actor[raise_no]);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
raise_no = !raise_no;
return TRUE;
}
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
static ClutterActor *
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone_box (ClutterActor *original)
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
{
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat width, height;
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
ClutterActor *group;
ClutterActor *clone;
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clutter_actor_get_size (original, &width, &height);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
group = clutter_group_new ();
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_depth (clone, width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_rotation (clone, CLUTTER_Y_AXIS, 180, width / 2, 0, 0);
clutter_actor_set_depth (clone, -width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
clutter_actor_set_rotation (clone, CLUTTER_Y_AXIS, 90, 0, 0, 0);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_depth (clone, width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (clone, 0, 0);
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
clutter_actor_set_rotation (clone, CLUTTER_Y_AXIS, 90, 0, 0, 0);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_depth (clone, width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (clone, width, 0);
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
clutter_actor_set_rotation (clone, CLUTTER_X_AXIS, 90, 0, 0, 0);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_depth (clone, -width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (clone, 0, height);
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
clone = clutter_clone_new (original);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (group), clone);
clutter_actor_set_rotation (clone, CLUTTER_X_AXIS, 90, 0, 0, 0);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_depth (clone, -width / 2);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (clone, 0, 0);
clutter_actor_show_all (group);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
return group;
}
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
static ClutterActor *
janus_group (const gchar *front_text,
const gchar *back_text)
{
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
ClutterColor slide_color = {0x00, 0x00, 0x00, 0xff};
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
ClutterColor red = {0xff, 0x00, 0x00, 0xff};
ClutterColor green = {0x00, 0xff, 0x00, 0xff};
ClutterActor *group, *rectangle, *front, *back;
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat width, height;
gfloat width2, height2;
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
group = clutter_group_new ();
rectangle = clutter_rectangle_new_with_color (&slide_color);
Update the interactive tests to ClutterText Instead of using ClutterLabel, use ClutterText to display some text where needed.
2008-12-11 13:48:01 +00:00
front = clutter_text_new_with_text ("Sans 50px", front_text);
back = clutter_text_new_with_text ("Sans 50px", back_text);
clutter_text_set_color (CLUTTER_TEXT (front), &red);
clutter_text_set_color (CLUTTER_TEXT (back), &green);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_actor_get_size (front, &width, &height);
clutter_actor_get_size (back, &width2, &height2);
if (width2 > width)
width = width2;
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
7 small miscellaneous fixes Bug#959 - Multiple minor improvements * configure.ac: pick up GDKPIXBUF_PREFIX from gdk-pixbuf-2.0 module, not pango * clutter/clutter-keysyms-table.h: cosmetic fix for ifdef guard name in the comment (leftover from earlier commit) * tests/test-textures.c: don't depend on GdkPixbuf as we're not using any actual features from it, just plain pixel buffer manipulation * clutter/clutter-timeline.c * clutter/clutter-timeline.h (clutter_timeline_list_markers): Use gsize* to return number of items, not guint* * tests/test-paint-wrapper.c: use correct type (guint*) in call to clutter_actor_get_size() * tests/test-depth.c (janus_group): properly take height2 into account when calculating needed height for the rectangle * tests/test-cogl-tex-getset.c: use rowstride, not width*4, when calculating pixel offsets * tests/test-cogl-tex-getset.c: Don't assume/force RGBA format, also support ARGB format (needed with quartz imageloader.)
2008-06-10 06:37:46 +00:00
if (height2 > height)
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
height = height2;
clutter_actor_set_size (rectangle, width, height);
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
clutter_actor_set_rotation (back, CLUTTER_Y_AXIS, 180, width / 2, 0, 0);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add (CLUTTER_CONTAINER (group),
back, rectangle, front, NULL);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_actor_show_all (group);
return group;
}
Bug 1162 - Re-works the tests/ to use the glib-2.16 unit testing framework * configure.ac: * tests/*: The tests have been reorganised into different categories: conformance, interactive and micro benchmarks. - conformance tests can be run as part of automated tests - interactive tests are basically all the existing tests - micro benchmarks focus on a single performance metric I converted the timeline tests to conformance tests and also added some tests from Neil Roberts and Ebassi. Note: currently only the conformance tests use the glib test APIs, though the micro benchmarks should too. The other change is to make the unit tests link into monolithic binaries which makes the build time for unit tests considerably faster. To deal with the extra complexity this adds to debugging individual tests I have added some sugar to the makefiles so all the tests can be run directly via a symlink and when an individual test is run this way, then a note is printed to the terminal explaining exactly how that test may be debugged using GDB. There is a convenience make rule: 'make test-report', that will run all the conformance tests and hopefully even open the results in your web browser. It skips some of the slower timeline tests, but you can run those using 'make full-report'
2008-11-07 19:32:28 +00:00
G_MODULE_EXPORT gint
test_depth_main (int argc, char *argv[])
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
{
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
ClutterTimeline *timeline;
ClutterBehaviour *d_behave;
ClutterBehaviour *r_behave;
ClutterActor *stage;
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
ClutterActor *group, *hand, *label, *rect, *janus, *box;
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
ClutterColor stage_color = { 0xcc, 0xcc, 0xcc, 0xff };
ClutterColor rect_color = { 0, 0, 0, 0x88 };
[stage] Coalesce fog and perspective API The fog and perspective API is currently split in two parts: - the floating point version, using values - the fixed point version, using structures The relative properties are using the structure types, since they are meant to set multiple values at the same time. Instead of using bare values, the whole API should be coalesced into two simple calls using structures to match the GObject properties. Thus: clutter_stage_set_fog (ClutterStage*, const ClutterFog*) clutter_stage_get_fog (ClutterStage*, ClutterFog*) clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*) clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*) Which supercedes the fixed point and floating point variants. More importantly, both ClutterFog and ClutterPerspective should using floating point values, since that's what get passed to COGL anyway. ClutterFog should also drop the "density" member, since ClutterStage only allows linear fog; non-linear fog distribution can be achieved using a signal handler and calling cogl_set_fog() directly; this keeps the API compact yet extensible. Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
ClutterFog stage_fog = { 10.0, -50.0 };
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
GError *error;
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
[stage] Coalesce fog and perspective API The fog and perspective API is currently split in two parts: - the floating point version, using values - the fixed point version, using structures The relative properties are using the structure types, since they are meant to set multiple values at the same time. Instead of using bare values, the whole API should be coalesced into two simple calls using structures to match the GObject properties. Thus: clutter_stage_set_fog (ClutterStage*, const ClutterFog*) clutter_stage_get_fog (ClutterStage*, ClutterFog*) clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*) clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*) Which supercedes the fixed point and floating point variants. More importantly, both ClutterFog and ClutterPerspective should using floating point values, since that's what get passed to COGL anyway. ClutterFog should also drop the "density" member, since ClutterStage only allows linear fog; non-linear fog distribution can be achieved using a signal handler and calling cogl_set_fog() directly; this keeps the API compact yet extensible. Finally, there is no ClutterStage:fog so it should be added.
2009-03-09 17:24:44 +00:00
clutter_stage_set_fog (CLUTTER_STAGE (stage), &stage_fog);
2007-11-21 Emmanuele Bassi <ebassi@openedhand.com> * clutter/cogl/cogl.h: Add cogl_fog_set() abstracting the glFog() functions and enabling the GL_FOG flag. * clutter/cogl/gl/cogl.c: Add GL implementation of cogl_fog_set(). * clutter/cogl/gles/cogl.c: Add GL/ES implementation of cogl_fog_set(). * clutter.symbols: Add new symbols. * clutter/clutter-stage.h: Add API to enable depth cueing on the stage using a linear GL fog, and to set the parameters for it (#637). * clutter/clutter-stage.c (clutter_stage_paint): Enable the GL fog if the ClutterStage:use-fog property is true. * tests/test-depth.c: Test the new stage API.
2007-11-21 11:55:26 +00:00
clutter_stage_set_use_fog (CLUTTER_STAGE (stage), TRUE);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
g_signal_connect (stage,
"button-press-event", G_CALLBACK (clutter_main_quit),
NULL);
2008-01-27 Emmanuele Bassi <ebassi@openedhand.com> * tests/test-depth.c (main): Use a group instead of pushing the actors on the stage.
2008-01-27 23:39:23 +00:00
group = clutter_group_new ();
clutter_stage_add (stage, group);
clutter_actor_show (group);
Update the interactive tests to ClutterText Instead of using ClutterLabel, use ClutterText to display some text where needed.
2008-12-11 13:48:01 +00:00
label = clutter_text_new_with_text ("Mono 26", "Clutter");
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (label, 120, 200);
2007-11-21 Emmanuele Bassi <ebassi@openedhand.com> * clutter/cogl/cogl.h: Add cogl_fog_set() abstracting the glFog() functions and enabling the GL_FOG flag. * clutter/cogl/gl/cogl.c: Add GL implementation of cogl_fog_set(). * clutter/cogl/gles/cogl.c: Add GL/ES implementation of cogl_fog_set(). * clutter.symbols: Add new symbols. * clutter/clutter-stage.h: Add API to enable depth cueing on the stage using a linear GL fog, and to set the parameters for it (#637). * clutter/clutter-stage.c (clutter_stage_paint): Enable the GL fog if the ClutterStage:use-fog property is true. * tests/test-depth.c: Test the new stage API.
2007-11-21 11:55:26 +00:00
clutter_actor_show (label);
Merged clutter-ivan branch into trunk. svn merge \ https://svn.o-hand.com/repos/clutter/trunk/clutter@2509 \ https://svn.o-hand.com/repos/clutter/branches/clutter-ivan@HEAD
2008-04-25 13:37:36 +00:00
error = NULL;
hand = clutter_texture_new_from_file ("redhand.png", &error);
if (error)
g_error ("Unable to load redhand.png: %s", error->message);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (hand, 240, 100);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
clutter_actor_show (hand);
2007-11-21 Emmanuele Bassi <ebassi@openedhand.com> * clutter/cogl/cogl.h: Add cogl_fog_set() abstracting the glFog() functions and enabling the GL_FOG flag. * clutter/cogl/gl/cogl.c: Add GL implementation of cogl_fog_set(). * clutter/cogl/gles/cogl.c: Add GL/ES implementation of cogl_fog_set(). * clutter.symbols: Add new symbols. * clutter/clutter-stage.h: Add API to enable depth cueing on the stage using a linear GL fog, and to set the parameters for it (#637). * clutter/clutter-stage.c (clutter_stage_paint): Enable the GL fog if the ClutterStage:use-fog property is true. * tests/test-depth.c: Test the new stage API.
2007-11-21 11:55:26 +00:00
rect = clutter_rectangle_new_with_color (&rect_color);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_actor_set_position (rect, 340, 100);
2007-11-21 Emmanuele Bassi <ebassi@openedhand.com> * clutter/cogl/cogl.h: Add cogl_fog_set() abstracting the glFog() functions and enabling the GL_FOG flag. * clutter/cogl/gl/cogl.c: Add GL implementation of cogl_fog_set(). * clutter/cogl/gles/cogl.c: Add GL/ES implementation of cogl_fog_set(). * clutter.symbols: Add new symbols. * clutter/clutter-stage.h: Add API to enable depth cueing on the stage using a linear GL fog, and to set the parameters for it (#637). * clutter/clutter-stage.c (clutter_stage_paint): Enable the GL fog if the ClutterStage:use-fog property is true. * tests/test-depth.c: Test the new stage API.
2007-11-21 11:55:26 +00:00
clutter_actor_set_size (rect, 200, 200);
clutter_actor_show (rect);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_container_add (CLUTTER_CONTAINER (group), hand, rect, NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
2007-11-21 Emmanuele Bassi <ebassi@openedhand.com> * clutter/cogl/cogl.h: Add cogl_fog_set() abstracting the glFog() functions and enabling the GL_FOG flag. * clutter/cogl/gl/cogl.c: Add GL implementation of cogl_fog_set(). * clutter/cogl/gles/cogl.c: Add GL/ES implementation of cogl_fog_set(). * clutter.symbols: Add new symbols. * clutter/clutter-stage.h: Add API to enable depth cueing on the stage using a linear GL fog, and to set the parameters for it (#637). * clutter/clutter-stage.c (clutter_stage_paint): Enable the GL fog if the ClutterStage:use-fog property is true. * tests/test-depth.c: Test the new stage API.
2007-11-21 11:55:26 +00:00
/* 3 seconds, at 60 fps */
[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 12:05:12 +00:00
timeline = clutter_timeline_new (3000);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
g_signal_connect (timeline,
"completed", G_CALLBACK (timeline_completed),
NULL);
[alpha] Allow registering alpha functions In order to unify alpha functions and animation modes in ClutterAlpha we should be able to register alpha functions and get a logical id for them; the logical id will then be available to be used by clutter_alpha_set_mode(). The registration requires API changes in ClutterAlpha constructors and methods. It also provides the chance to shift ClutterAlpha towards the use of animations modes only, and to alpha functions as a convenience API for language bindings alone.
2009-01-16 13:42:06 +00:00
d_behave =
clutter_behaviour_depth_new (clutter_alpha_new_full (timeline,
CLUTTER_LINEAR),
-100, 100);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_behaviour_apply (d_behave, label);
/* add two faced actor */
janus = janus_group ("GREEN", "RED");
clutter_container_add_actor (CLUTTER_CONTAINER (stage), janus);
clutter_actor_set_position (janus, 300, 350);
[alpha] Allow registering alpha functions In order to unify alpha functions and animation modes in ClutterAlpha we should be able to register alpha functions and get a logical id for them; the logical id will then be available to be used by clutter_alpha_set_mode(). The registration requires API changes in ClutterAlpha constructors and methods. It also provides the chance to shift ClutterAlpha towards the use of animations modes only, and to alpha functions as a convenience API for language bindings alone.
2009-01-16 13:42:06 +00:00
r_behave =
clutter_behaviour_rotate_new (clutter_alpha_new_full (timeline,
CLUTTER_LINEAR),
CLUTTER_Y_AXIS,
CLUTTER_ROTATE_CW,
0, 360);
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
clutter_behaviour_apply (r_behave, janus);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
/* add hand box */
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
box = clone_box (hand);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
clutter_actor_set_position (box, 200, 250);
clutter_actor_set_scale (box, 0.5, 0.5);
clutter_actor_set_rotation (box, CLUTTER_X_AXIS, 45, 0, 0, 0);
clutter_actor_set_opacity (box, 0x44);
[alpha] Allow registering alpha functions In order to unify alpha functions and animation modes in ClutterAlpha we should be able to register alpha functions and get a logical id for them; the logical id will then be available to be used by clutter_alpha_set_mode(). The registration requires API changes in ClutterAlpha constructors and methods. It also provides the chance to shift ClutterAlpha towards the use of animations modes only, and to alpha functions as a convenience API for language bindings alone.
2009-01-16 13:42:06 +00:00
r_behave =
clutter_behaviour_rotate_new (clutter_alpha_new_full (timeline,
CLUTTER_LINEAR),
CLUTTER_Y_AXIS,
CLUTTER_ROTATE_CW,
0, 360);
* tests/test-depth.c: added a box of cloned hands to further expand the scope of depth testing scenarios exercised by test-depth.
2008-01-31 16:55:34 +00:00
clutter_behaviour_apply (r_behave, box);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
clutter_actor_show (stage);
clutter_timeline_start (timeline);
2008-10-08 Emmanuele Bassi <ebassi@linux.intel.com> * tests/test-depth.c (raise_top), (main): Fix a shadowing with raise() from signal.h.
2008-10-08 19:50:22 +00:00
raise_actor[0] = rect;
raise_actor[1] = hand;
* tests/test-depth.c: (timeline_completed): make use of clutter_timeline_set_direction instead of static state. (raise_top): made rectangle remain at fixed depth and raise above each other. (janus_group): added a rectangle with two faces, one red and one green, that spins around.
2008-01-31 14:42:49 +00:00
g_timeout_add (2000, raise_top, NULL);
2007-08-04 Emmanuele Bassi <ebassi@openedhand.com> * clutter/clutter-behaviour-depth.c: Clarify that what drives the movement along the Z axis is the ClutterAlpha object (we don't have the luxury of a rollover like the opacity does); so, if you want to go from 0 to -100 you have to use a decreasing function, just as well if you want to go from 100 to 0. Using a min-depth of 100 and a max-depth of 0 and an increasing function is undefined behaviour. * tests/Makefile.am: * tests/test-depth.c: Add a test case for the depth behaviour.
2007-08-04 08:59:18 +00:00
clutter_main ();
g_object_unref (d_behave);
g_object_unref (timeline);
return EXIT_SUCCESS;
}
Reference in New Issue Copy Permalink