isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-24 12:02:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
b97a6e62a3
mutter/clutter/clutter/clutter-master-clock.h

70 lines
3.2 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/>.
*/
#ifndef __CLUTTER_MASTER_CLOCK_H__
#define __CLUTTER_MASTER_CLOCK_H__
#include <clutter/clutter-timeline.h>
G_BEGIN_DECLS
clutter: MasterClock: Use G_DECLARE_INTERFACE() It cuts away a bit of the GObject boilerplate, gives us support for `g_autoptr`, and removes the typedef hack inside clutter-master-clock.c. https://gitlab.gnome.org/GNOME/mutter/merge_requests/380
2019-01-08 14:35:01 +00:00
#define CLUTTER_TYPE_MASTER_CLOCK (clutter_master_clock_get_type ())
G_DECLARE_INTERFACE (ClutterMasterClock, clutter_master_clock,
CLUTTER, MASTER_CLOCK,
GObject)
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: MasterClock: Use G_DECLARE_INTERFACE() It cuts away a bit of the GObject boilerplate, gives us support for `g_autoptr`, and removes the typedef hack inside clutter-master-clock.c. https://gitlab.gnome.org/GNOME/mutter/merge_requests/380
2019-01-08 14:35:01 +00:00
struct _ClutterMasterClockInterface
main: Make the MasterClock an interface Move the implementation of the MasterClock into MasterClockDefault, so backends can provide their own implementation. https://bugzilla.gnome.org/show_bug.cgi?id=744668
2015-02-17 14:50:13 +00:00
{
/*< private >*/
GTypeInterface parent_iface;
void (* add_timeline) (ClutterMasterClock *master_clock,
ClutterTimeline *timeline);
void (* remove_timeline) (ClutterMasterClock *master_clock,
ClutterTimeline *timeline);
void (* start_running) (ClutterMasterClock *master_clock);
void (* ensure_next_iteration) (ClutterMasterClock *master_clock);
void (* set_paused) (ClutterMasterClock *master_clock,
gboolean paused);
};
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
Clean up clutter-timeline.h Re-align everything to allow expansion, and move the only "protected" function to the clutter-master-clock.h private header.
2012-02-13 13:39:47 +00:00
ClutterMasterClock * _clutter_master_clock_get_default (void);
void _clutter_master_clock_add_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline);
void _clutter_master_clock_remove_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline);
void _clutter_master_clock_start_running (ClutterMasterClock *master_clock);
void _clutter_master_clock_ensure_next_iteration (ClutterMasterClock *master_clock);
egl: Add a way to pause the ClutterMasterClock When VT switched away, we need to pause the ClutterMasterClock, stop processing events, and stop trying to flip. https://bugzilla.gnome.org/show_bug.cgi?id=730215
2014-02-28 15:15:45 +00:00
void _clutter_master_clock_set_paused (ClutterMasterClock *master_clock,
gboolean paused);
Clean up clutter-timeline.h Re-align everything to allow expansion, and move the only "protected" function to the clutter-master-clock.h private header.
2012-02-13 13:39:47 +00:00
timeline: Add an internal function for advancing a timeline There are cases when we want to advance a timeline from another time source. We cannot use _clutter_timeline_do_tick() directly, as that assumes that the timeline is already playing, so we'll need to create a wrapper that toggles the playing flag around it.
2012-03-21 16:07:29 +00:00
void _clutter_timeline_advance (ClutterTimeline *timeline,
gint64 tick_time);
gint64 _clutter_timeline_get_delta (ClutterTimeline *timeline);
Clean up clutter-timeline.h Re-align everything to allow expansion, and move the only "protected" function to the clutter-master-clock.h private header.
2012-02-13 13:39:47 +00:00
void _clutter_timeline_do_tick (ClutterTimeline *timeline,
gint64 tick_time);
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_END_DECLS
#endif /* __CLUTTER_MASTER_CLOCK_H__ */
Reference in New Issue Copy Permalink