isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-27 10:30:47 -05:00
Code Issues Packages Projects Releases Wiki Activity
f4fd724caf
mutter/cogl/cogl-onscreen-private.h

124 lines
3.0 KiB
C
Raw Normal View History

framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
Add a callback to get dirty events from a CoglOnscreen This adds a callback that can be registered with cogl_onscreen_add_dirty_callback which will get called whenever the window system determines that the contents of the window is dirty and needs to be redrawn. Under the two X-based winsys's, this is reported off the back of the Expose events, under SDL it is reported from SDL_VIDEOEXPOSE or SDL_WINDOWEVENT_EXPOSED and under Windows from the WM_PAINT messages. The Wayland winsys doesn't really have the concept of dirtying the buffer but in order to allow applications to work the same way on all platforms it will emit the event when the surface is first shown and whenever it is resized. There is a private feature flag to specify whether dirty events are supported. If the winsys does not set this then Cogl will simulate dirty events by emitting one when the window is first allocated and when it is resized. The only winsys's that don't set this flag are things like KMS or the EGL null winsys where there is no windowing system and showing and hiding the onscreen doesn't really make any sense. In that case Cogl can assume the buffer will only become dirty once when it is first allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85c5a9ba419b2247bd768284c79ee69164a0c098) Conflicts: cogl/cogl-private.h
2013-05-14 08:39:48 -04:00
* Copyright (C) 2011,2013 Intel Corporation.
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
*
* 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 __COGL_ONSCREEN_PRIVATE_H
#define __COGL_ONSCREEN_PRIVATE_H
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
#include "cogl-onscreen.h"
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
#include "cogl-framebuffer-private.h"
Fix build on OSX A missing include prevents Cogl from building on OSX. Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-15 09:55:31 -05:00
#include "cogl-queue.h"
Adds internal cogl closure list utility This adds some utility code to help us manage lists of closures consistently within Cogl. The utilities are from Rig and were originally written by Neil Roberts. This adapts the way we track CoglOnscreen resize and frame closures to use the new utilities. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 2e15fc76eb29bf5932418f7ee80f1fcb2f6a816c)
2013-04-17 19:27:26 -04:00
#include "cogl-closure-list-private.h"
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
#include <glib.h>
#ifdef COGL_HAS_WIN32_SUPPORT
#include <windows.h>
#endif
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
typedef struct _CoglOnscreenEvent CoglOnscreenEvent;
COGL_TAILQ_HEAD (CoglOnscreenEventList, CoglOnscreenEvent);
struct _CoglOnscreenEvent
{
COGL_TAILQ_ENTRY (CoglOnscreenEvent) list_node;
CoglOnscreen *onscreen;
CoglFrameInfo *info;
CoglFrameEvent type;
};
Add a callback to get dirty events from a CoglOnscreen This adds a callback that can be registered with cogl_onscreen_add_dirty_callback which will get called whenever the window system determines that the contents of the window is dirty and needs to be redrawn. Under the two X-based winsys's, this is reported off the back of the Expose events, under SDL it is reported from SDL_VIDEOEXPOSE or SDL_WINDOWEVENT_EXPOSED and under Windows from the WM_PAINT messages. The Wayland winsys doesn't really have the concept of dirtying the buffer but in order to allow applications to work the same way on all platforms it will emit the event when the surface is first shown and whenever it is resized. There is a private feature flag to specify whether dirty events are supported. If the winsys does not set this then Cogl will simulate dirty events by emitting one when the window is first allocated and when it is resized. The only winsys's that don't set this flag are things like KMS or the EGL null winsys where there is no windowing system and showing and hiding the onscreen doesn't really make any sense. In that case Cogl can assume the buffer will only become dirty once when it is first allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85c5a9ba419b2247bd768284c79ee69164a0c098) Conflicts: cogl/cogl-private.h
2013-05-14 08:39:48 -04:00
typedef struct _CoglOnscreenQueuedDirty CoglOnscreenQueuedDirty;
COGL_TAILQ_HEAD (CoglOnscreenQueuedDirtyList, CoglOnscreenQueuedDirty);
struct _CoglOnscreenQueuedDirty
{
COGL_TAILQ_ENTRY (CoglOnscreenQueuedDirty) list_node;
CoglOnscreen *onscreen;
CoglOnscreenDirtyInfo info;
};
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
struct _CoglOnscreen
{
CoglFramebuffer _parent;
#ifdef COGL_HAS_X11_SUPPORT
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
uint32_t foreign_xid;
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
CoglOnscreenX11MaskCallback foreign_update_mask_callback;
void *foreign_update_mask_data;
#endif
#ifdef COGL_HAS_WIN32_SUPPORT
HWND foreign_hwnd;
#endif
wayland: implement foreign surfaces for CoglOnscreen This adds support for optionally providing a foreign Wayland surface to a CoglOnscreen before allocation. Setting a foreign surface prevents Cogl from creating a toplevel Wayland shell surface for the OnScreen. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit e447d9878f3bcfe5fe336d367238383b02879223)
2013-04-25 13:30:42 -04:00
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
struct wl_surface *foreign_surface;
#endif
Switch use of primitive glib types to c99 equivalents The coding style has for a long time said to avoid using redundant glib data types such as gint or gchar etc because we feel that they make the code look unnecessarily foreign to developers coming from outside of the Gnome developer community. Note: When we tried to find the historical rationale for the types we just found that they were apparently only added for consistent syntax highlighting which didn't seem that compelling. Up until now we have been continuing to use some of the platform specific type such as gint{8,16,32,64} and gsize but this patch switches us over to using the standard c99 equivalents instead so we can further ensure that our code looks familiar to the widest range of C developers who might potentially contribute to Cogl. So instead of using the gint{8,16,32,64} and guint{8,16,32,64} types this switches all Cogl code to instead use the int{8,16,32,64}_t and uint{8,16,32,64}_t c99 types instead. Instead of gsize we now use size_t For now we are not going to use the c99 _Bool type and instead we have introduced a new CoglBool type to use instead of gboolean. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 5967dad2400d32ca6319cef6cb572e81bf2c15f0)
2012-04-16 16:56:40 -04:00
CoglBool swap_throttled;
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
Adds internal cogl closure list utility This adds some utility code to help us manage lists of closures consistently within Cogl. The utilities are from Rig and were originally written by Neil Roberts. This adapts the way we track CoglOnscreen resize and frame closures to use the new utilities. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 2e15fc76eb29bf5932418f7ee80f1fcb2f6a816c)
2013-04-17 19:27:26 -04:00
CoglClosureList frame_closures;
Move the add_swap_buffers_callback functions out of the winsys Instead of having each winsys implement its own list of callbacks the list is now just attached directly to the CoglOnscreen using code in cogl-onscreen.c. The winsys's can invoke this list of callbacks by calling _cogl_onscreen_notify_swap_buffers(). All of the winsys's would probably have a very similar implementation for this anyway and I don't think it makes much sense to try and save the cost of a list pointer in the CoglOnscreen struct. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:26:44 -05:00
onscreen: Adds support for resizable windows This adds api to be able to request that the window system allows a given onscreen framebuffer to be resizable, and api to add and remove resize handlers to be called whenever the framebuffer does actually change size. The new functions are: cogl_onscreen_{get,set}_resizable() cogl_onscreen_{add,remove}_resize_handler() The examples cogl-hello and cogl-x11-foreign have been updated to use the new api. To smoke test how Cogl updates the viewport automatically in response to window resizes the cogl-hello test doesn't explicitly respond to resize events by setting the viewport and cogl-x11-foreign responds by setting a viewport that is offset by a quarter of the window's width/height and half the width and height of the window. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1a8cc00bfa2cecaf1007aec5f3dd95dc07b1786)
2012-06-20 11:22:36 -04:00
CoglBool resizable;
Adds internal cogl closure list utility This adds some utility code to help us manage lists of closures consistently within Cogl. The utilities are from Rig and were originally written by Neil Roberts. This adapts the way we track CoglOnscreen resize and frame closures to use the new utilities. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 2e15fc76eb29bf5932418f7ee80f1fcb2f6a816c)
2013-04-17 19:27:26 -04:00
CoglClosureList resize_closures;
onscreen: Adds support for resizable windows This adds api to be able to request that the window system allows a given onscreen framebuffer to be resizable, and api to add and remove resize handlers to be called whenever the framebuffer does actually change size. The new functions are: cogl_onscreen_{get,set}_resizable() cogl_onscreen_{add,remove}_resize_handler() The examples cogl-hello and cogl-x11-foreign have been updated to use the new api. To smoke test how Cogl updates the viewport automatically in response to window resizes the cogl-hello test doesn't explicitly respond to resize events by setting the viewport and cogl-x11-foreign responds by setting a viewport that is offset by a quarter of the window's width/height and half the width and height of the window. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1a8cc00bfa2cecaf1007aec5f3dd95dc07b1786)
2012-06-20 11:22:36 -04:00
Add a callback to get dirty events from a CoglOnscreen This adds a callback that can be registered with cogl_onscreen_add_dirty_callback which will get called whenever the window system determines that the contents of the window is dirty and needs to be redrawn. Under the two X-based winsys's, this is reported off the back of the Expose events, under SDL it is reported from SDL_VIDEOEXPOSE or SDL_WINDOWEVENT_EXPOSED and under Windows from the WM_PAINT messages. The Wayland winsys doesn't really have the concept of dirtying the buffer but in order to allow applications to work the same way on all platforms it will emit the event when the surface is first shown and whenever it is resized. There is a private feature flag to specify whether dirty events are supported. If the winsys does not set this then Cogl will simulate dirty events by emitting one when the window is first allocated and when it is resized. The only winsys's that don't set this flag are things like KMS or the EGL null winsys where there is no windowing system and showing and hiding the onscreen doesn't really make any sense. In that case Cogl can assume the buffer will only become dirty once when it is first allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85c5a9ba419b2247bd768284c79ee69164a0c098) Conflicts: cogl/cogl-private.h
2013-05-14 08:39:48 -04:00
CoglClosureList dirty_closures;
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
int64_t frame_counter;
int64_t swap_frame_counter; /* frame counter at last all to
* cogl_onscreen_swap_region() or
* cogl_onscreen_swap_buffers() */
GQueue pending_frame_infos;
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
void *winsys;
};
object: Remove the type member of CoglObjectClass Unlike in GObject the type number for a CoglObject is entirely an internal implementation detail so there is no need to make a GQuark to make it safe to export out of the library. Instead we can just directly use a fixed pointer address as the identifier for the type. This patch makes it use the address of the class struct of the identifier. This should make it faster to do type checks because it does not need to call a function every time it wants to get the type number. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-24 11:24:26 -05:00
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
CoglOnscreen *
_cogl_onscreen_new (void);
void
_cogl_framebuffer_winsys_update_size (CoglFramebuffer *framebuffer,
int width, int height);
Move the add_swap_buffers_callback functions out of the winsys Instead of having each winsys implement its own list of callbacks the list is now just attached directly to the CoglOnscreen using code in cogl-onscreen.c. The winsys's can invoke this list of callbacks by calling _cogl_onscreen_notify_swap_buffers(). All of the winsys's would probably have a very similar implementation for this anyway and I don't think it makes much sense to try and save the cost of a list pointer in the CoglOnscreen struct. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:26:44 -05:00
void
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
_cogl_onscreen_notify_frame_sync (CoglOnscreen *onscreen, CoglFrameInfo *info);
void
_cogl_onscreen_notify_complete (CoglOnscreen *onscreen, CoglFrameInfo *info);
Move the add_swap_buffers_callback functions out of the winsys Instead of having each winsys implement its own list of callbacks the list is now just attached directly to the CoglOnscreen using code in cogl-onscreen.c. The winsys's can invoke this list of callbacks by calling _cogl_onscreen_notify_swap_buffers(). All of the winsys's would probably have a very similar implementation for this anyway and I don't think it makes much sense to try and save the cost of a list pointer in the CoglOnscreen struct. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-19 14:26:44 -05:00
onscreen: Adds support for resizable windows This adds api to be able to request that the window system allows a given onscreen framebuffer to be resizable, and api to add and remove resize handlers to be called whenever the framebuffer does actually change size. The new functions are: cogl_onscreen_{get,set}_resizable() cogl_onscreen_{add,remove}_resize_handler() The examples cogl-hello and cogl-x11-foreign have been updated to use the new api. To smoke test how Cogl updates the viewport automatically in response to window resizes the cogl-hello test doesn't explicitly respond to resize events by setting the viewport and cogl-x11-foreign responds by setting a viewport that is offset by a quarter of the window's width/height and half the width and height of the window. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit a1a8cc00bfa2cecaf1007aec5f3dd95dc07b1786)
2012-06-20 11:22:36 -04:00
void
_cogl_onscreen_notify_resize (CoglOnscreen *onscreen);
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
void
Add a callback to get dirty events from a CoglOnscreen This adds a callback that can be registered with cogl_onscreen_add_dirty_callback which will get called whenever the window system determines that the contents of the window is dirty and needs to be redrawn. Under the two X-based winsys's, this is reported off the back of the Expose events, under SDL it is reported from SDL_VIDEOEXPOSE or SDL_WINDOWEVENT_EXPOSED and under Windows from the WM_PAINT messages. The Wayland winsys doesn't really have the concept of dirtying the buffer but in order to allow applications to work the same way on all platforms it will emit the event when the surface is first shown and whenever it is resized. There is a private feature flag to specify whether dirty events are supported. If the winsys does not set this then Cogl will simulate dirty events by emitting one when the window is first allocated and when it is resized. The only winsys's that don't set this flag are things like KMS or the EGL null winsys where there is no windowing system and showing and hiding the onscreen doesn't really make any sense. In that case Cogl can assume the buffer will only become dirty once when it is first allocated. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85c5a9ba419b2247bd768284c79ee69164a0c098) Conflicts: cogl/cogl-private.h
2013-05-14 08:39:48 -04:00
_cogl_onscreen_queue_dirty (CoglOnscreen *onscreen,
const CoglOnscreenDirtyInfo *info);
void
_cogl_onscreen_queue_full_dirty (CoglOnscreen *onscreen);
onscreen: Add CoglFrameInfo and _add_frame_callback() api Add a CoglFrameInfo object that tracks timing information for frames that are drawn. We track a frame counter and frame timing information for each CoglOnscreen. Internally a CoglFrameInfo is automatically created for each frame, delimited by cogl_onscreen_swap_buffers() or cogl_onscreen_swap_region() calls. CoglFrameInfos are delivered to applications via frame event callbacks that can be registered with a new cogl_onscreen_add_frame_callback() api. Two initial event types (dispatched on all platforms) have been defined; a _SYNC event used for throttling the frame rate of applications and a _COMPLETE event used so signify the end of a frame. Note: This new _add_frame_callback() api makes the cogl_onscreen_add_swap_complete_callback() api redundant and so it should be considered deprecated. Since the _add_swap_complete_callback() api is still experimental api, we will be looking to quickly migrate users to the new api so we can remove the old api. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 700401667db2522045e4623d78797b17f9184501)
2012-11-12 11:58:10 -05:00
framebuffer: split out CoglOnscreen code This factors out the CoglOnscreen code from cogl-framebuffer.c so we now have cogl-onscreen.c, cogl-onscreen.h and cogl-onscreen-private.h. Notably some of the functions pulled out are currently namespaced as cogl_framebuffer but we know we are planning on renaming them to be in the cogl_onscreen namespace; such as cogl_framebuffer_swap_buffers(). Reviewed-by: Neil Roberts <neil@linux.intel.com>
2011-10-13 16:31:04 -04:00
#endif /* __COGL_ONSCREEN_PRIVATE_H */
Reference in New Issue Copy Permalink