brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
683642ba54
mutter/clutter/clutter-master-clock.c

599 lines
18 KiB
C
Raw Normal View History

Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* SECTION:clutter-master-clock
* @short_description: The master clock for all animations
*
* The #ClutterMasterClock class is responsible for advancing all
* #ClutterTimelines when a stage is being redrawn. The master clock
* makes sure that the scenegraph is always integrally updated before
* painting it.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-master-clock.h"
#include "clutter-debug.h"
#include "clutter-private.h"
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
#include "clutter-profile.h"
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 11:16:05 +00:00
#include "clutter-stage-manager-private.h"
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 10:29:09 +00:00
#include "clutter-stage-private.h"
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
#define CLUTTER_MASTER_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockClass))
#define CLUTTER_IS_MASTER_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MASTER_CLOCK))
#define CLUTTER_MASTER_CLASS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockClass))
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
typedef struct _ClutterClockSource ClutterClockSource;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
typedef struct _ClutterMasterClockClass ClutterMasterClockClass;
struct _ClutterMasterClock
{
GObject parent_instance;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
/* the list of timelines handled by the clock */
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
GSList *timelines;
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* the current state of the clock, in usecs */
gint64 cur_tick;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* the previous state of the clock, in usecs, used to compute the delta */
gint64 prev_tick;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
/* an idle source, used by the Master Clock to queue
* a redraw on the stage and drive the animations
*/
GSource *source;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* If the master clock is idle that means it has
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
* fallen back to idle polling for timeline
* progressions and it may have been some time since
* the last real stage update.
*/
guint idle : 1;
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
guint ensure_next_iteration : 1;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
};
struct _ClutterMasterClockClass
{
GObjectClass parent_class;
};
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
struct _ClutterClockSource
{
GSource source;
ClutterMasterClock *master_clock;
};
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean clutter_clock_prepare (GSource *source,
gint *timeout);
static gboolean clutter_clock_check (GSource *source);
static gboolean clutter_clock_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data);
static ClutterMasterClock *default_clock = NULL;
static GSourceFuncs clock_funcs = {
clutter_clock_prepare,
clutter_clock_check,
clutter_clock_dispatch,
NULL
};
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
G_DEFINE_TYPE (ClutterMasterClock, clutter_master_clock, G_TYPE_OBJECT);
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
/*
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
* master_clock_is_running:
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
* @master_clock: a #ClutterMasterClock
*
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
* Checks if we should currently be advancing timelines or redrawing
* stages.
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
*
* Return value: %TRUE if the #ClutterMasterClock has at least
* one running timeline
*/
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
master_clock_is_running (ClutterMasterClock *master_clock)
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
{
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
gboolean stage_free = FALSE;
stages = clutter_stage_manager_peek_stages (stage_manager);
/* If all of the stages are busy waiting for a swap-buffers to complete
* then we stop the master clock... */
for (l = stages; l != NULL; l = l->next)
stage: Add sanity checks for get_pending_swaps() The master clock might have a Stage during its destruction phase, without a StageWindow attached to it. If this happens and we try to dereference the StageWindow to get its class and call a virtual function we might experience some slight turbulence and... then... explode. http://bugzilla.openedhand.com/show_bug.cgi?id=1987
2010-02-15 12:04:50 +00:00
{
if (_clutter_stage_get_pending_swaps (l->data) == 0)
{
stage_free = TRUE;
break;
}
}
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
if (!stage_free)
return FALSE;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
if (master_clock->timelines)
return TRUE;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
for (l = stages; l; l = l->next)
stage: Add sanity checks for get_pending_swaps() The master clock might have a Stage during its destruction phase, without a StageWindow attached to it. If this happens and we try to dereference the StageWindow to get its class and call a virtual function we might experience some slight turbulence and... then... explode. http://bugzilla.openedhand.com/show_bug.cgi?id=1987
2010-02-15 12:04:50 +00:00
{
if (_clutter_stage_has_queued_events (l->data) ||
_clutter_stage_needs_update (l->data))
return TRUE;
}
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
if (master_clock->ensure_next_iteration)
{
master_clock->ensure_next_iteration = FALSE;
return TRUE;
}
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
return FALSE;
}
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
/*
* master_clock_next_frame_delay:
* @master_clock: a #ClutterMasterClock
*
* Computes the number of delay before we need to draw the next frame.
*
* Return value: -1 if there is no next frame pending, otherwise the
* number of millseconds before the we need to draw the next frame
*/
static gint
master_clock_next_frame_delay (ClutterMasterClock *master_clock)
{
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
gint64 now, next;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
if (!master_clock_is_running (master_clock))
return -1;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
/* When we have sync-to-vblank, we count on swap-buffer requests (or
* swap-buffer-complete events if supported in the backend) to throttle our
* frame rate so no additional delay is needed to start the next frame.
*
* If the master-clock has become idle due to no timeline progression causing
* redraws then we can no longer rely on vblank synchronization because the
* last real stage update/redraw may have happened a long time ago and so we
* fallback to polling for timeline progressions every 1/frame_rate seconds.
*
* (NB: if there aren't even any timelines running then the master clock will
* be completely stopped in master_clock_is_running())
*/
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
if (clutter_feature_available (CLUTTER_FEATURE_SYNC_TO_VBLANK) &&
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
!master_clock->idle)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "vblank available and updated stages");
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (master_clock->prev_tick == 0)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
/* If we weren't previously running, then draw the next frame
* immediately
*/
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
/* Otherwise, wait at least 1/frame_rate seconds since we last
* started a frame
*/
Start using the monotonic API in GLib ≥ 2.27 Starting from the 2.27 cycle, GLib is exposing a monotonic clock with microseconds granularity throughout the time-based API. We can start using it, given that the old, non-monotonic version is going to be deprecated by the same cycle.
2010-11-07 16:20:51 +00:00
#if GLIB_CHECK_VERSION (2, 27, 3)
now = g_source_get_time (master_clock->source);
#else
{
GTimeVal source_time;
g_source_get_current_time (master_clock->source, &source_time);
now = source_time.tv_sec * 1000000L + source_time.tv_usec;
}
#endif
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
next = master_clock->prev_tick;
clutter-master-clock: Don't wait for a frame if time goes backwards If we aren't syncing to vblank or if the last dispatch didn't cause a redraw then the master clock will try to wait at least a small amount of time before dispatching again. However if time goes backwards then it would not do a dispatch until time catches up again. To fix this it know just runs a dispatch immediately if time goes backwards. This is related to Moblin bug #3839. There was a similar fix for this in 9dc012c07, however that only fixed the case where timelines wouldn't update. If there are no animations running then the master clock won't even try updating timelines until time catches up. http://bugzilla.o-hand.com/show_bug.cgi?id=1974
2010-02-05 21:56:31 +00:00
/* If time has gone backwards then there's no way of knowing how
long we should wait so let's just dispatch immediately */
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (now <= next)
clutter-master-clock: Don't wait for a frame if time goes backwards If we aren't syncing to vblank or if the last dispatch didn't cause a redraw then the master clock will try to wait at least a small amount of time before dispatching again. However if time goes backwards then it would not do a dispatch until time catches up again. To fix this it know just runs a dispatch immediately if time goes backwards. This is related to Moblin bug #3839. There was a similar fix for this in 9dc012c07, however that only fixed the case where timelines wouldn't update. If there are no animations running then the master clock won't even try updating timelines until time catches up. http://bugzilla.o-hand.com/show_bug.cgi?id=1974
2010-02-05 21:56:31 +00:00
{
CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
return 0;
}
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
next += (1000000L / clutter_get_default_frame_rate ());
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (next <= now)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
1000000L / (gulong) clutter_get_default_frame_rate ());
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
else
{
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
(next - now) / 1000);
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
return (next - now) / 1000;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
}
}
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
/*
* clutter_clock_source_new:
* @master_clock: a #ClutterMasterClock for the source
*
* The #ClutterClockSource is an idle GSource that will queue a redraw
* if @master_clock has at least a running #ClutterTimeline. The redraw
* will cause @master_clock to advance all timelines, thus advancing all
* animations as well.
*
* Return value: the newly created #GSource
*/
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static GSource *
clutter_clock_source_new (ClutterMasterClock *master_clock)
{
GSource *source = g_source_new (&clock_funcs, sizeof (ClutterClockSource));
ClutterClockSource *clock_source = (ClutterClockSource *) source;
g_source_set_name on custom sources (if available) Call g_source_set_name, if the versio of GLib is new enough. This aids debugging, using e.g. SystemTap. See https://bugzilla.gnome.org/show_bug.cgi?id=620511 for more information http://bugzilla.openedhand.com/show_bug.cgi?id=2151 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-06-04 03:34:09 +00:00
g_source_set_name (source, "Clutter master clock");
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
clock_source->master_clock = master_clock;
return source;
}
static gboolean
clutter_clock_prepare (GSource *source,
gint *timeout)
{
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
int delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_enter ();
Add a CLUTTER_PAINT debug option to enable continous redrawing When testing the performance of an application, it's often useful to force it to continuously redraw instead of going idle to help measure the frame rate. This just adds a CLUTTER_PAINT=continuous-redraw which causes the master clock to queue a redraw on all of the stages just before it prepares its source. Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-23 14:12:44 +00:00
if (G_UNLIKELY (clutter_paint_debug_flags &
CLUTTER_DEBUG_CONTINUOUS_REDRAW))
{
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
stages = clutter_stage_manager_peek_stages (stage_manager);
/* Queue a full redraw on all of the stages */
for (l = stages; l != NULL; l = l->next)
clutter_actor_queue_redraw (l->data);
}
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
delay = master_clock_next_frame_delay (master_clock);
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_leave ();
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
*timeout = delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return delay == 0;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
}
static gboolean
clutter_clock_check (GSource *source)
{
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
int delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_enter ();
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
delay = master_clock_next_frame_delay (master_clock);
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_leave ();
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return delay == 0;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
}
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean
clutter_clock_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
gboolean stages_updated = FALSE;
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
GSList *stages, *l;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_STATIC_TIMER (master_dispatch_timer,
"Mainloop",
"Master Clock",
"Master clock dispatch",
0);
CLUTTER_STATIC_TIMER (master_event_process,
"Master Clock",
"Event Processing",
"The time spent processing events on all stages",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_dispatch_timer);
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_enter ();
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* Get the time to use for this frame */
Start using the monotonic API in GLib ≥ 2.27 Starting from the 2.27 cycle, GLib is exposing a monotonic clock with microseconds granularity throughout the time-based API. We can start using it, given that the old, non-monotonic version is going to be deprecated by the same cycle.
2010-11-07 16:20:51 +00:00
#if GLIB_CHECK_VERSION (2, 27, 3)
master_clock->cur_tick = g_source_get_time (source);
#else
{
GTimeVal source_time;
g_source_get_current_time (source, &source_time);
master_clock->cur_tick = source_time.tv_sec * 1000000L
+ source_time.tv_usec;
}
#endif
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
/* We need to protect ourselves against stages being destroyed during
* event handling
*/
stages = clutter_stage_manager_list_stages (stage_manager);
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
g_slist_foreach (stages, (GFunc) g_object_ref, NULL);
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_TIMER_START (_clutter_uprof_context, master_event_process);
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
master_clock->idle = FALSE;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
/* Process queued events */
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
for (l = stages; l != NULL; l = l->next)
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
{
/* NB: If a stage is busy waiting for a swap-buffers completion then
* we don't process its events so we can maximize the benefits of
* motion compression, and avoid multiple picks per frame.
*/
if (_clutter_stage_get_pending_swaps (l->data) == 0)
_clutter_stage_process_queued_events (l->data);
}
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_event_process);
Run the repaint functions inside the redraw cycle Now that every redraw is performed within the master clock we need to run the repaint functions inside it.
2009-06-09 15:28:25 +00:00
_clutter_master_clock_advance (master_clock);
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
Run the repaint functions inside the redraw cycle Now that every redraw is performed within the master clock we need to run the repaint functions inside it.
2009-06-09 15:28:25 +00:00
_clutter_run_repaint_functions ();
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
/* Update any stage that needs redraw/relayout after the clock
* is advanced.
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
*/
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
for (l = stages; l != NULL; l = l->next)
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
{
/* If a stage has a swap-buffers pending we don't want to draw to it
* in case the driver may block the CPU while it waits for the next
* backbuffer to become available.
*
* TODO: We should be able to identify if we are running triple or N
* buffered and in these cases we can still draw if there is 1 swap
* pending so we can hopefully always be ready to swap for the next
* vblank and really match the vsync frequency.
*/
if (_clutter_stage_get_pending_swaps (l->data) == 0)
stages_updated |= _clutter_stage_do_update (l->data);
}
/* The master clock goes idle if no stages were updated and falls back
* to polling for timeline progressions... */
if (!stages_updated)
master_clock->idle = TRUE;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
g_slist_foreach (stages, (GFunc) g_object_unref, NULL);
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
g_slist_free (stages);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
master_clock->prev_tick = master_clock->cur_tick;
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
clutter_threads_leave ();
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_dispatch_timer);
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
return TRUE;
}
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
static void
clutter_master_clock_finalize (GObject *gobject)
{
ClutterMasterClock *master_clock = CLUTTER_MASTER_CLOCK (gobject);
g_slist_free (master_clock->timelines);
G_OBJECT_CLASS (clutter_master_clock_parent_class)->finalize (gobject);
}
static void
clutter_master_clock_class_init (ClutterMasterClockClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = clutter_master_clock_finalize;
}
static void
clutter_master_clock_init (ClutterMasterClock *self)
{
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
GSource *source;
source = clutter_clock_source_new (self);
self->source = source;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
self->idle = FALSE;
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
self->ensure_next_iteration = FALSE;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
g_source_set_can_recurse (source, FALSE);
g_source_attach (source, NULL);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_get_default:
*
* Retrieves the default master clock. If this function has never
* been called before, the default master clock is created.
*
* Return value: the default master clock. The returned object is
* owned by Clutter and should not be modified or freed
*/
ClutterMasterClock *
_clutter_master_clock_get_default (void)
{
if (G_LIKELY (default_clock != NULL))
return default_clock;
default_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK, NULL);
return default_clock;
}
/*
* _clutter_master_clock_add_timeline:
* @master_clock: a #ClutterMasterClock
* @timeline: a #ClutterTimeline
*
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
* Adds @timeline to the list of playing timelines held by the master
* clock.
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
*/
void
_clutter_master_clock_add_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline)
{
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
gboolean is_first;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
if (g_slist_find (master_clock->timelines, timeline))
return;
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
is_first = master_clock->timelines == NULL;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
master_clock->timelines = g_slist_prepend (master_clock->timelines,
timeline);
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
if (is_first)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
_clutter_master_clock_start_running (master_clock);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_remove_timeline:
* @master_clock: a #ClutterMasterClock
* @timeline: a #ClutterTimeline
*
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
* Removes @timeline from the list of playing timelines held by the
* master clock.
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
*/
void
_clutter_master_clock_remove_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline)
{
master_clock->timelines = g_slist_remove (master_clock->timelines,
timeline);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
}
/*
* _clutter_master_clock_start_running:
* @master_clock: a #ClutterMasterClock
*
* Called when we have events or redraws to process; if the clock
* is stopped, does the processing necessary to wake it up again.
*/
void
_clutter_master_clock_start_running (ClutterMasterClock *master_clock)
{
/* If called from a different thread, we need to wake up the
* main loop to start running the timelines
*/
g_main_context_wakeup (NULL);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_advance:
* @master_clock: a #ClutterMasterClock
*
* Advances all the timelines held by the master clock. This function
Remove mentions of clutter_redraw()
2011-10-17 09:25:07 +00:00
* should be called before calling _clutter_stage_do_update() to
* make sure that all the timelines are advanced and the scene is updated.
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
*/
void
_clutter_master_clock_advance (ClutterMasterClock *master_clock)
{
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
GSList *timelines, *l;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_STATIC_TIMER (master_timeline_advance,
"Master Clock",
"Timelines Advancement",
"The time spent advancing all timelines",
0);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
CLUTTER_TIMER_START (_clutter_uprof_context, master_timeline_advance);
master-clock: Take a reference before advancing timelines A timeline advancement might cause another timeline to be destroyed, which will likely lead to a segmentation fault. Before advancing the timelines we should take a reference on them - just like we do for the stages before doing event processing. This will prevent dispose() from running until the end of the advancement. http://bugzilla.openedhand.com/show_bug.cgi?id=1854
2009-11-11 11:00:29 +00:00
/* we protect ourselves from timelines being removed during
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
* the advancement by other timelines by copying the list of
* timelines, taking a reference on them, iterating over the
* copied list and then releasing the reference.
*
* we cannot simply take a reference on the timelines and still
* use the list held by the master clock because the do_tick()
* might result in the creation of a new timeline, which gets
* added at the end of the list with no reference increase and
* thus gets disposed at the end of the iteration.
*
* this implies that a newly added timeline will not be advanced
* by this clock iteration, which is perfectly fine since we're
* in its first cycle.
*
* we also cannot steal the master clock timelines list because
* a timeline might be removed as the direct result of do_tick()
* and remove_timeline() would not find the timeline, failing
* and leaving a dangling pointer behind.
master-clock: Take a reference before advancing timelines A timeline advancement might cause another timeline to be destroyed, which will likely lead to a segmentation fault. Before advancing the timelines we should take a reference on them - just like we do for the stages before doing event processing. This will prevent dispose() from running until the end of the advancement. http://bugzilla.openedhand.com/show_bug.cgi?id=1854
2009-11-11 11:00:29 +00:00
*/
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
timelines = g_slist_copy (master_clock->timelines);
g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
master-clock: Take a reference before advancing timelines A timeline advancement might cause another timeline to be destroyed, which will likely lead to a segmentation fault. Before advancing the timelines we should take a reference on them - just like we do for the stages before doing event processing. This will prevent dispose() from running until the end of the advancement. http://bugzilla.openedhand.com/show_bug.cgi?id=1854
2009-11-11 11:00:29 +00:00
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
for (l = timelines; l != NULL; l = l->next)
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
_clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
master clock: Improve the timeline advancement protection The commit 1c69c61745ed510f0b6ab16cb963ca01994cb9fc which improved the protection against timeline removals during the master clock advancement was only doing half the job - and actually broke the chaining of animations inside the ::completed signal. We cannot simply take a reference on the timelines and still use the list held by the master clock because the do_tick() might result in the creation of a new timeline, which gets added at the end of the list with no reference increase and thus gets disposed at the end of the iteration. We also cannot steal the master clock timelines list because a timeline might be removed as the direct result of do_tick() and remove_timeline() would not find the timeline, failing and leaving a dangling pointer behind. For this reason we copy the list of timelines out of the one that the Master Clock holds, take a reference on each timeline, advance them all, release the reference and free the list.
2010-01-21 23:41:18 +00:00
g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
g_slist_free (timelines);
master-clock: Take a reference before advancing timelines A timeline advancement might cause another timeline to be destroyed, which will likely lead to a segmentation fault. Before advancing the timelines we should take a reference on them - just like we do for the stages before doing event processing. This will prevent dispose() from running until the end of the advancement. http://bugzilla.openedhand.com/show_bug.cgi?id=1854
2009-11-11 11:00:29 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_timeline_advance);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
/**
* _clutter_master_clock_ensure_next_iteration:
* @master_clock: a #ClutterMasterClock
*
* Ensures that the master clock will run at least one iteration
*/
void
_clutter_master_clock_ensure_next_iteration (ClutterMasterClock *master_clock)
{
g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
master_clock->ensure_next_iteration = TRUE;
}
Reference in New Issue Copy Permalink