isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2025-02-20 15:04:09 +00:00
Code Issues Packages Projects Releases Wiki Activity
mutter/clutter/clutter/clutter-stage-private.h

150 lines
8.3 KiB
C
Raw Normal View History

Add copyright notices
2010-10-21 13:13:00 +01:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 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/>.
*/
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
#ifndef __CLUTTER_STAGE_PRIVATE_H__
#define __CLUTTER_STAGE_PRIVATE_H__
#include <clutter/clutter-stage-window.h>
#include <clutter/clutter-stage.h>
Clean up crossing event synthesis code Clutter should just require that the windowing system used by a backend adds a device to the stage when the device enters, and removes it from the stage when the device leaves; with this information, we can synthesize every crossing event and update the device state without other intervention from the backend-specific code. The generation of additional crossing events for actors that are covering the stage at the coordinates of the crossing event should be delegated to the event processing code. The x11 and win32 backends need to be modified to relay the enter and leave events from the windowing system.
2011-01-27 17:26:16 +00:00
#include <clutter/clutter-input-device.h>
Optimize culling by doing culling in eye-coordinates This implements a variation of frustum culling whereby we convert screen space clip rectangles into eye space mini-frustums so that we don't have to repeatedly transform actor paint-volumes all the way into screen coordinates to perform culling, we just have to apply the modelview transform and then determine each points distance from the planes that make up the clip frustum. By avoiding the projective transform, perspective divide and viewport scale for each point culled this makes culling much cheaper.
2011-02-01 18:32:08 +00:00
#include <clutter/clutter-private.h>
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
stage: adds internal_get_active_framebuffer API This adds an internal _clutter_stage_get_active_framebuffer function that can be used to get a pointer to the current CoglFramebuffer pointer that is in use, in association with a given stage. The "active" infix in the function name is there because we shouldn't assume that a stage will always correspond to only a single framebuffer so we aren't getting a pointer to a sole framebuffer, we are getting a pointer to the framebuffer that is currently in use/being painted. This API is now used for culling purposes where we need to check if we are currently painting an actor to a framebuffer that is offscreen, that doesn't correspond to the stage.
2011-03-10 22:05:03 +00:00
#include <cogl/cogl.h>
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
G_BEGIN_DECLS
typedef struct _ClutterStageQueueRedrawEntry ClutterStageQueueRedrawEntry;
/* stage */
ClutterStageWindow *_clutter_stage_get_default_window (void);
Remove internal usage of ClutterGeometry in StageWindow The ClutterGeometry type is a poor substitute of cairo_rectangle_int_t, with unsigned integers for width and height to complicate matters. Let's remove the internal usage of ClutterGeometry and switch to the rectangle type from Cairo. https://bugzilla.gnome.org/show_bug.cgi?id=656663
2011-08-16 16:01:22 +01:00
Introduce regional stage rendering Add support for drawing a stage using multiple framebuffers each making up one part of the stage. This works by the stage backend (ClutterStageWindow) providing a list of views which will be for splitting up the stage in different regions. A view layout, for now, is a set of rectangles. The stage window (i.e. stage "backend" will use this information when drawing a frame, using one framebuffer for each view. The scene graph is adapted to explictly take a view when painting the stage. It will use this view, its assigned framebuffer and layout to offset and clip the drawing accordingly. This effectively removes any notion of "stage framebuffer", since each stage now may consist of multiple framebuffers. Therefore, API involving this has been deprecated and made no-ops; namely clutter_stage_ensure_context(). Callers are now assumed to either always use a framebuffer reference explicitly, or push/pop the framebuffer of a given view where the code has not yet changed to use the explicit-buffer-using cogl API. Currently only the nested X11 backend supports this mode fully, and the per view framebuffers are all offscreen. Upon frame completion, it'll blit each view's framebuffer onto the onscreen framebuffer before swapping. Other backends (X11 CM and native/KMS) are adapted to manage a full-stage view. The X11 CM backend will continue to use this method, while the native/KMS backend will be adopted to use multiple view drawing. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-27 11:09:24 +08:00
void _clutter_stage_paint_view (ClutterStage *stage,
ClutterStageView *view,
Remove internal usage of ClutterGeometry in StageWindow The ClutterGeometry type is a poor substitute of cairo_rectangle_int_t, with unsigned integers for width and height to complicate matters. Let's remove the internal usage of ClutterGeometry and switch to the rectangle type from Cairo. https://bugzilla.gnome.org/show_bug.cgi?id=656663
2011-08-16 16:01:22 +01:00
const cairo_rectangle_int_t *clip);
clutter/stage: Emit after-paint after painting ClutterStage:after-paint is supposed to be emitted after all painting is done, but before the frame is finished. However, as it is right now, it is being emitted after each view is painted -- on multi-monitor setups, after-frame is being emitted multiple times. Send after-paint only once, after all views are painted and before finishing the frame. https://gitlab.gnome.org/GNOME/mutter/merge_requests/623
2019-06-17 19:16:47 -03:00
void _clutter_stage_emit_after_paint (ClutterStage *stage);
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_set_window (ClutterStage *stage,
ClutterStageWindow *stage_window);
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
ClutterStageWindow *_clutter_stage_get_window (ClutterStage *stage);
void _clutter_stage_get_projection_matrix (ClutterStage *stage,
CoglMatrix *projection);
void _clutter_stage_dirty_projection (ClutterStage *stage);
void _clutter_stage_set_viewport (ClutterStage *stage,
viewport: consistently use floats for viewports OpenGL < 4.0 only supports integer based viewports and internally we have a mixture of code using floats and integers for viewports. This patch switches all viewports throughout clutter and cogl to be represented using floats considering that in the future we may want to take advantage of floating point viewports with modern hardware/drivers.
2011-02-01 16:51:58 +00:00
float x,
float y,
float width,
float height);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_get_viewport (ClutterStage *stage,
viewport: consistently use floats for viewports OpenGL < 4.0 only supports integer based viewports and internally we have a mixture of code using floats and integers for viewports. This patch switches all viewports throughout clutter and cogl to be represented using floats considering that in the future we may want to take advantage of floating point viewports with modern hardware/drivers.
2011-02-01 16:51:58 +00:00
float *x,
float *y,
float *width,
float *height);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_dirty_viewport (ClutterStage *stage);
Introduce regional stage rendering Add support for drawing a stage using multiple framebuffers each making up one part of the stage. This works by the stage backend (ClutterStageWindow) providing a list of views which will be for splitting up the stage in different regions. A view layout, for now, is a set of rectangles. The stage window (i.e. stage "backend" will use this information when drawing a frame, using one framebuffer for each view. The scene graph is adapted to explictly take a view when painting the stage. It will use this view, its assigned framebuffer and layout to offset and clip the drawing accordingly. This effectively removes any notion of "stage framebuffer", since each stage now may consist of multiple framebuffers. Therefore, API involving this has been deprecated and made no-ops; namely clutter_stage_ensure_context(). Callers are now assumed to either always use a framebuffer reference explicitly, or push/pop the framebuffer of a given view where the code has not yet changed to use the explicit-buffer-using cogl API. Currently only the nested X11 backend supports this mode fully, and the per view framebuffers are all offscreen. Upon frame completion, it'll blit each view's framebuffer onto the onscreen framebuffer before swapping. Other backends (X11 CM and native/KMS) are adapted to manage a full-stage view. The X11 CM backend will continue to use this method, while the native/KMS backend will be adopted to use multiple view drawing. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-05-27 11:09:24 +08:00
void _clutter_stage_maybe_setup_viewport (ClutterStage *stage,
ClutterStageView *view);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_maybe_relayout (ClutterActor *stage);
gboolean _clutter_stage_needs_update (ClutterStage *stage);
gboolean _clutter_stage_do_update (ClutterStage *stage);
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_queue_event (ClutterStage *stage,
Avoid needless event copies when queueing from a backend to a stage All backends follow the same pattern of queueing events first in ClutterMainContext, then copying them to a ClutterStage queue and immediately free them. Instead, we can just pass ownership of events directly to ClutterStage thus avoiding the allocation and copy in between. https://bugzilla.gnome.org/show_bug.cgi?id=711857
2013-11-11 18:16:32 +01:00
ClutterEvent *event,
gboolean copy_event);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
gboolean _clutter_stage_has_queued_events (ClutterStage *stage);
void _clutter_stage_process_queued_events (ClutterStage *stage);
void _clutter_stage_update_input_devices (ClutterStage *stage);
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 12:42:24 -05:00
void _clutter_stage_schedule_update (ClutterStage *stage);
gint64 _clutter_stage_get_update_time (ClutterStage *stage);
void _clutter_stage_clear_update_time (ClutterStage *stage);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
gboolean _clutter_stage_has_full_redraw_queued (ClutterStage *stage);
stage: Move _clutter_do_pick to clutter-stage.c This moves the implementation of _clutter_do_pick to clutter-stage.c and renames it _clutter_stage_do_pick. This function can be compared to _clutter_stage_do_update/redraw in that it prepares for and starts a traversal of a scenegraph descending from a given stage. Since it is desirable that this function should have access to the private state of the stage it is awkward to maintain outside of clutter-stage.c. Besides moving _clutter_do_pick this patch is also able to remove the following private state accessors from clutter-stage-private.h: _clutter_stage_set_pick_buffer_valid, _clutter_stage_get_pick_buffer_valid, _clutter_stage_increment_picks_per_frame_counter, _clutter_stage_reset_picks_per_frame_counter and _clutter_stage_get_picks_per_frame_counter.
2011-03-15 13:17:04 +00:00
Replace ClutterPoint by graphene_point_t Remove the tests for ClutterPoint since it's corresponding code moved to private ClutterStage methods. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 11:53:44 -03:00
void clutter_stage_log_pick (ClutterStage *stage,
const graphene_point_t *vertices,
ClutterActor *actor);
clutter: Introduce geometric picking Currently, Clutter does picking by drawing with Cogl and reading the pixel that's beneath the given point. Since Cogl has a journal that records drawing operations, and has optimizations to read a single pixel from a list of rectangle, it would be expected that we would hit this fast path and not flush the journal while picking. However, that's not the case: dithering, clipping with scissors, etc, can all flush the journal, issuing commands to the GPU and making picking slow. On NVidia-based systems, this glReadPixels() call is extremely costly. Introduce geometric picking, and avoid using the Cogl journal entirely. Do this by introducing a stack of actors in ClutterStage. This stack is cached, but for now, don't use the cache as much as possible. The picking routines are still tied to painting. When projecting the actor vertexes, do it manually and take the modelview matrix of the framebuffer into account as well. CPU usage on an Intel i7-7700, tested with two different GPUs/drivers: | | Intel | Nvidia | | ------: | --------: | -----: | | Moving the mouse: | | Before | 10% | 10% | | After | 6% | 6% | | Moving a window: | | Before | 23% | 81% | | After | 19% | 40% | Closes: https://gitlab.gnome.org/GNOME/mutter/issues/154, https://gitlab.gnome.org/GNOME/mutter/issues/691 Helps significantly with: https://gitlab.gnome.org/GNOME/mutter/issues/283, https://gitlab.gnome.org/GNOME/mutter/issues/590, https://gitlab.gnome.org/GNOME/mutter/issues/700 v2: Fix code style issues Simplify quadrilateral checks Remove the 0.5f hack Differentiate axis-aligned rectangles https://gitlab.gnome.org/GNOME/mutter/merge_requests/189
2018-08-02 19:03:30 +08:00
Replace ClutterPoint by graphene_point_t Remove the tests for ClutterPoint since it's corresponding code moved to private ClutterStage methods. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 11:53:44 -03:00
void clutter_stage_push_pick_clip (ClutterStage *stage,
const graphene_point_t *vertices);
clutter: Introduce geometric picking Currently, Clutter does picking by drawing with Cogl and reading the pixel that's beneath the given point. Since Cogl has a journal that records drawing operations, and has optimizations to read a single pixel from a list of rectangle, it would be expected that we would hit this fast path and not flush the journal while picking. However, that's not the case: dithering, clipping with scissors, etc, can all flush the journal, issuing commands to the GPU and making picking slow. On NVidia-based systems, this glReadPixels() call is extremely costly. Introduce geometric picking, and avoid using the Cogl journal entirely. Do this by introducing a stack of actors in ClutterStage. This stack is cached, but for now, don't use the cache as much as possible. The picking routines are still tied to painting. When projecting the actor vertexes, do it manually and take the modelview matrix of the framebuffer into account as well. CPU usage on an Intel i7-7700, tested with two different GPUs/drivers: | | Intel | Nvidia | | ------: | --------: | -----: | | Moving the mouse: | | Before | 10% | 10% | | After | 6% | 6% | | Moving a window: | | Before | 23% | 81% | | After | 19% | 40% | Closes: https://gitlab.gnome.org/GNOME/mutter/issues/154, https://gitlab.gnome.org/GNOME/mutter/issues/691 Helps significantly with: https://gitlab.gnome.org/GNOME/mutter/issues/283, https://gitlab.gnome.org/GNOME/mutter/issues/590, https://gitlab.gnome.org/GNOME/mutter/issues/700 v2: Fix code style issues Simplify quadrilateral checks Remove the 0.5f hack Differentiate axis-aligned rectangles https://gitlab.gnome.org/GNOME/mutter/merge_requests/189
2018-08-02 19:03:30 +08:00
void clutter_stage_pop_pick_clip (ClutterStage *stage);
stage: Move _clutter_do_pick to clutter-stage.c This moves the implementation of _clutter_do_pick to clutter-stage.c and renames it _clutter_stage_do_pick. This function can be compared to _clutter_stage_do_update/redraw in that it prepares for and starts a traversal of a scenegraph descending from a given stage. Since it is desirable that this function should have access to the private state of the stage it is awkward to maintain outside of clutter-stage.c. Besides moving _clutter_do_pick this patch is also able to remove the following private state accessors from clutter-stage-private.h: _clutter_stage_set_pick_buffer_valid, _clutter_stage_get_pick_buffer_valid, _clutter_stage_increment_picks_per_frame_counter, _clutter_stage_reset_picks_per_frame_counter and _clutter_stage_get_picks_per_frame_counter.
2011-03-15 13:17:04 +00:00
ClutterActor *_clutter_stage_do_pick (ClutterStage *stage,
clutter/stage: Do picking with float coordinates Previously picking was done on an int (x,y) to address a particular pixel. While `int` was the minimum precision required, it was also an unnecessary type conversion. The callers (input events mainly) all provide float coordinates and the internal picking calculations also have always used floats. So it was inconsistent and unnecessary to drop to integer precision in between those. ABI break: This changes the parameter types for public function `clutter_stage_get_actor_at_pos`, but its documentation is already sufficiently vague to not need changing. https://gitlab.gnome.org/GNOME/mutter/merge_requests/844
2019-10-11 15:52:56 +08:00
float x,
float y,
stage: Move _clutter_do_pick to clutter-stage.c This moves the implementation of _clutter_do_pick to clutter-stage.c and renames it _clutter_stage_do_pick. This function can be compared to _clutter_stage_do_update/redraw in that it prepares for and starts a traversal of a scenegraph descending from a given stage. Since it is desirable that this function should have access to the private state of the stage it is awkward to maintain outside of clutter-stage.c. Besides moving _clutter_do_pick this patch is also able to remove the following private state accessors from clutter-stage-private.h: _clutter_stage_set_pick_buffer_valid, _clutter_stage_get_pick_buffer_valid, _clutter_stage_increment_picks_per_frame_counter, _clutter_stage_reset_picks_per_frame_counter and _clutter_stage_get_picks_per_frame_counter.
2011-03-15 13:17:04 +00:00
ClutterPickMode mode);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
ClutterPaintVolume *_clutter_stage_paint_volume_stack_allocate (ClutterStage *stage);
void _clutter_stage_paint_volume_stack_free_all (ClutterStage *stage);
Optimize culling by doing culling in eye-coordinates This implements a variation of frustum culling whereby we convert screen space clip rectangles into eye space mini-frustums so that we don't have to repeatedly transform actor paint-volumes all the way into screen coordinates to perform culling, we just have to apply the modelview transform and then determine each points distance from the planes that make up the clip frustum. By avoiding the projective transform, perspective divide and viewport scale for each point culled this makes culling much cheaper.
2011-02-01 18:32:08 +00:00
const ClutterPlane *_clutter_stage_get_clip (ClutterStage *stage);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
ClutterStageQueueRedrawEntry *_clutter_stage_queue_actor_redraw (ClutterStage *stage,
ClutterStageQueueRedrawEntry *entry,
ClutterActor *actor,
clutter: Make paint volume argument const on queue_redraw*() The given paint volume is actually unmodified, there is no need to require non-const arguments when some getters actually give const paint volumes.
2018-08-15 01:12:49 +02:00
const ClutterPaintVolume *clip);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
void _clutter_stage_queue_redraw_entry_invalidate (ClutterStageQueueRedrawEntry *entry);
drag/drop actions: add touch event support https://bugzilla.gnome.org/show_bug.cgi?id=678049
2012-06-13 16:02:05 +01:00
void _clutter_stage_add_pointer_drag_actor (ClutterStage *stage,
ClutterInputDevice *device,
ClutterActor *actor);
ClutterActor * _clutter_stage_get_pointer_drag_actor (ClutterStage *stage,
ClutterInputDevice *device);
void _clutter_stage_remove_pointer_drag_actor (ClutterStage *stage,
ClutterInputDevice *device);
void _clutter_stage_add_touch_drag_actor (ClutterStage *stage,
ClutterEventSequence *sequence,
ClutterActor *actor);
ClutterActor * _clutter_stage_get_touch_drag_actor (ClutterStage *stage,
ClutterEventSequence *sequence);
void _clutter_stage_remove_touch_drag_actor (ClutterStage *stage,
ClutterEventSequence *sequence);
stage: Allow tracking dragged actors We should be able to internally attach the actor currently being dragged to the device that is dragging it. https://bugzilla.gnome.org/show_bug.cgi?id=652842
2011-06-17 16:51:05 +01:00
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
stage: Add state tracking State changes on the Stage are currently deferred to the windowing system backends, but the code is generally the same, and it should be abstracted neatly inside the Stage class itself. There's also the extra caveat for backends that state changes on a Stage must also emit a ClutterEvent of type CLUTTER_STAGE_STATE, a requirement that needlessly complicates the backend code.
2012-01-25 21:24:47 +00:00
ClutterStageState _clutter_stage_get_state (ClutterStage *stage);
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
stage: Add state tracking State changes on the Stage are currently deferred to the windowing system backends, but the code is generally the same, and it should be abstracted neatly inside the Stage class itself. There's also the extra caveat for backends that state changes on a Stage must also emit a ClutterEvent of type CLUTTER_STAGE_STATE, a requirement that needlessly complicates the backend code.
2012-01-25 21:24:47 +00:00
gboolean _clutter_stage_is_activated (ClutterStage *stage);
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 13:53:00 +01:00
CLUTTER_EXPORT
stage: Add state tracking State changes on the Stage are currently deferred to the windowing system backends, but the code is generally the same, and it should be abstracted neatly inside the Stage class itself. There's also the extra caveat for backends that state changes on a Stage must also emit a ClutterEvent of type CLUTTER_STAGE_STATE, a requirement that needlessly complicates the backend code.
2012-01-25 21:24:47 +00:00
gboolean _clutter_stage_update_state (ClutterStage *stage,
ClutterStageState unset_state,
ClutterStageState set_state);
stage: Adjust drawing to include the window scaling factor In order to transparently support high DPI density displays, we must maintain all coordinates and sizes exactly as they are now — but draw them on a surface that is scaled up by a certain factor. In order to do that we have to change the viewport and initial transformation matrix so that they are scaled up by the same factor. https://bugzilla.gnome.org/show_bug.cgi?id=705915
2013-08-14 11:19:22 +01:00
void _clutter_stage_set_scale_factor (ClutterStage *stage,
int factor);
Replace ClutterRect by graphene_rect_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 12:23:04 -03:00
gboolean _clutter_stage_get_max_view_scale_factor_for_rect (ClutterStage *stage,
graphene_rect_t *rect,
float *view_scale);
stage: Adjust drawing to include the window scaling factor In order to transparently support high DPI density displays, we must maintain all coordinates and sizes exactly as they are now — but draw them on a surface that is scaled up by a certain factor. In order to do that we have to change the viewport and initial transformation matrix so that they are scaled up by the same factor. https://bugzilla.gnome.org/show_bug.cgi?id=705915
2013-08-14 11:19:22 +01:00
Use signals instead of onscreen framebuffer frame callbacks CoglFrameInfo is a frame info container associated with a single onscreen framebuffer. The clutter stage will eventually support drawing a stage frame with multiple onscreen framebuffers, thus needs its own frame info container. This patch introduces a new stage signal 'presented' and a accompaning ClutterFrameInfo and adapts the stage windows and past onscreen frame callbacks users to use the signal and new info container. https://bugzilla.gnome.org/show_bug.cgi?id=768976
2016-06-08 13:07:09 +08:00
void _clutter_stage_presented (ClutterStage *stage,
CoglFrameEvent frame_event,
ClutterFrameInfo *frame_info);
clutter: Add API to get the resource scale of an actor A clutter actor might be painted on a stage view with a view scale other than 1. In this case, to show the content in full resolution, the actor must use a higher resolution resource (e.g. texture), which will be down scaled to the stage coordinate space, then scaled up again to the stage view framebuffer scale. Use a 'resource-scale' property to save information and notify when it changes. The resource scale is the ceiled value of the highest stage view scale a actor is visible on. The value is ceiled because using a higher resolution resource consistently results in better output quality. One reason for this is that rendering is often not perfectly pixel aligned, meaning even if we load a resource with a suitable size, due to us still scaling ever so slightly, the quality is affected. Using a higher resolution resource avoids this problem. For situations inside clutter where the actual maximum view scale is needed, a function _clutter_actor_get_real_resource_scale() is provided, which returns the non-ceiled value. Make sure we ignore resource scale computation requests during size requests or allocation while ensure we've proper resource-scale on pre-paint. https://bugzilla.gnome.org/show_bug.cgi?id=765011 https://gitlab.gnome.org/GNOME/mutter/merge_requests/3
2017-04-07 14:06:36 +02:00
GList * _clutter_stage_peek_stage_views (ClutterStage *stage);
clutter/stage: Add an API for shallow relayouts Where "shallow" means you can specify any actor instead of every relayout having to start from the stage. https://gitlab.gnome.org/GNOME/mutter/merge_requests/575
2019-05-07 13:02:55 +08:00
void clutter_stage_queue_actor_relayout (ClutterStage *stage,
ClutterActor *actor);
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 11:29:09 +01:00
G_END_DECLS
#endif /* __CLUTTER_STAGE_PRIVATE_H__ */
Reference in New Issue Copy Permalink