isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-22 16:10:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
38ddecf503
mutter/cogl/winsys/cogl-winsys-egl-wayland.c

819 lines
26 KiB
C
Raw Normal View History

Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 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/>.
*
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
#include <wayland-client.h>
#include <wayland-egl.h>
#include <string.h>
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
#include <errno.h>
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
#include "cogl-winsys-egl-wayland-private.h"
#include "cogl-winsys-egl-private.h"
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
#include "cogl-renderer-private.h"
#include "cogl-onscreen-private.h"
cogl-winsys-egl-wayland: Include cogl-wayland-renderer.h The Wayland winsys defines functions declared in cogl-wayland-renderer.h so it should include the header to make sure the declarations are right. This was breaking because currently the header #defines the _EXP suffixes on to the function names so it would end up exporting the wrong symbol names.
2012-02-29 12:45:43 -05:00
#include "cogl-wayland-renderer.h"
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
#include "cogl-error-private.h"
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 11:26:21 -04:00
#include "cogl-poll-private.h"
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
#include "cogl-frame-info-private.h"
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
static const CoglWinsysEGLVtable _cogl_winsys_egl_vtable;
static const CoglWinsysVtable *parent_vtable;
typedef struct _CoglRendererWayland
{
struct wl_display *wayland_display;
struct wl_compositor *wayland_compositor;
struct wl_shell *wayland_shell;
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
struct wl_registry *wayland_registry;
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 11:26:21 -04:00
int fd;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
} CoglRendererWayland;
typedef struct _CoglDisplayWayland
{
struct wl_surface *wayland_surface;
struct wl_egl_window *wayland_egl_native_window;
} CoglDisplayWayland;
typedef struct _CoglOnscreenWayland
{
struct wl_egl_window *wayland_egl_native_window;
struct wl_surface *wayland_surface;
struct wl_shell_surface *wayland_shell_surface;
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
/* Resizing a wayland framebuffer doesn't take affect
* until the next swap buffers request, so we have to
* track the resize geometry until then... */
int pending_width;
int pending_height;
int pending_dx;
int pending_dy;
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 has_pending;
wayland: Don't set the surface to toplevel until it is shown If we delay setting the surface to toplevel until it is shown then that gives the application an opportunity to avoid calling show so that it can set its own surface type. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ab59c3a421968d7f159d89ca2f0ba8a9f098cbf6)
2013-05-15 11:34:15 -04:00
CoglBool shell_surface_type_set;
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
CoglList frame_callbacks;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
} CoglOnscreenWayland;
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
typedef struct
{
CoglList link;
CoglFrameInfo *frame_info;
struct wl_callback *callback;
CoglOnscreen *onscreen;
} FrameCallbackData;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
static void
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
registry_handle_global_cb (void *data,
struct wl_registry *registry,
uint32_t id,
const char *interface,
uint32_t version)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
CoglRendererEGL *egl_renderer = (CoglRendererEGL *)data;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
if (strcmp (interface, "wl_compositor") == 0)
wayland_renderer->wayland_compositor =
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
wl_registry_bind (registry, id, &wl_compositor_interface, 1);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
else if (strcmp(interface, "wl_shell") == 0)
wayland_renderer->wayland_shell =
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
wl_registry_bind (registry, id, &wl_shell_interface, 1);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
}
static void
_cogl_winsys_renderer_disconnect (CoglRenderer *renderer)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
wayland: Disconnect the display when the renderer disconnects If we don't do this then it might leak connections to the display if multiple different renderers are tried. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8e5b4d40a4d960d0d20927d30ee68a37387fe776)
2013-06-28 07:09:35 -04:00
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland: Call eglTerminate before destroying wl_display, not after The eglTerminate code in Mesa will try to destroy the wl_drm object which involves using data structures in the wl_display. Cogl was disconnecting the display before calling eglTerminate which meant that this would end up accessing potentially garbage data. https://bugzilla.gnome.org/show_bug.cgi?id=705591 Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 358d85f35d0fe36698b758163729c4551fe5fd25)
2013-08-19 10:08:37 -04:00
if (egl_renderer->edpy)
eglTerminate (egl_renderer->edpy);
wayland: Disconnect the display when the renderer disconnects If we don't do this then it might leak connections to the display if multiple different renderers are tried. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8e5b4d40a4d960d0d20927d30ee68a37387fe776)
2013-06-28 07:09:35 -04:00
if (wayland_renderer->wayland_display)
{
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
if (renderer->foreign_wayland_display == NULL)
wl_display_disconnect (wayland_renderer->wayland_display);
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
g_slice_free (CoglRendererWayland, egl_renderer->platform);
g_slice_free (CoglRendererEGL, egl_renderer);
}
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
static const struct wl_registry_listener registry_listener = {
registry_handle_global_cb,
};
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
static int64_t
prepare_wayland_display_events (void *user_data)
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
int flush_ret;
flush_ret = wl_display_flush (wayland_renderer->wayland_display);
wayland: Remove the Wayland socket FD if there are any errors Previously if the Wayland socket gets closed then Cogl would ignore the error when dispatching events which meant the socket would be constantly ready for reading, the main loop would never go idle and it would sit at 100% CPU. When Wayland encounters an error it will actually close the socket which means if something else opened another file then we might even end up polling on a completely unrelated FD. This patch makes it remove the FD from the main loop as soon as it hits an error so that it will at least avoid breaking the main loop. However I think most applications would probably want to abort in this case so we might also want to add a way to inform the application of this or even just abort directly. The cogl_poll_* functions have been changed so that they can cope if the pending and dispatch callbacks remove their own FD while they are invoked. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85857b10687a5a246a0a4ef42711e560c7a6f45d)
2013-07-09 08:39:11 -04:00
if (flush_ret == -1)
{
/* If the socket buffer became full then we need to wake up the
* main loop once it is writable again */
if (errno == EAGAIN)
{
_cogl_poll_renderer_modify_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN |
COGL_POLL_FD_EVENT_OUT);
}
else if (errno != EINTR)
{
/* If the flush failed for some other reason then it's
* likely that it's going to consistently fail so we'll stop
* waiting on the file descriptor instead of making the
* application take up 100% CPU. FIXME: it would be nice if
* there was some way to report this to the application so
* that it can quit or recover */
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
}
}
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
/* Calling this here is a bit dodgy because Cogl usually tries to
* say that it won't do any event processing until
* cogl_poll_renderer_dispatch is called. However Wayland doesn't
* seem to provide any way to query whether the event queue is empty
* and we would need to do that in order to force the main loop to
* wake up to call it from dispatch. */
wl_display_dispatch_pending (wayland_renderer->wayland_display);
return -1;
}
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 11:26:21 -04:00
static void
poll: Add general way to hook into mainloop without fd This adds a _cogl_poll_renderer_add_source() function that we can use within cogl to hook into the mainloop without necessarily having a file descriptor to poll. Since the intention is to use this to support polling for fence completions this also updates the CoglPollCheckCallback type to take a timeout pointer so sources can optionally update the timeout that will be passed to poll. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 81c1ce0ffce4e75e08622e20848405987e00b3cc)
2013-05-13 21:51:55 -04:00
dispatch_wayland_display_events (void *user_data, int revents)
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 11:26:21 -04:00
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
if ((revents & COGL_POLL_FD_EVENT_IN))
wayland: Remove the Wayland socket FD if there are any errors Previously if the Wayland socket gets closed then Cogl would ignore the error when dispatching events which meant the socket would be constantly ready for reading, the main loop would never go idle and it would sit at 100% CPU. When Wayland encounters an error it will actually close the socket which means if something else opened another file then we might even end up polling on a completely unrelated FD. This patch makes it remove the FD from the main loop as soon as it hits an error so that it will at least avoid breaking the main loop. However I think most applications would probably want to abort in this case so we might also want to add a way to inform the application of this or even just abort directly. The cogl_poll_* functions have been changed so that they can cope if the pending and dispatch callbacks remove their own FD while they are invoked. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85857b10687a5a246a0a4ef42711e560c7a6f45d)
2013-07-09 08:39:11 -04:00
{
if (wl_display_dispatch (wayland_renderer->wayland_display) == -1 &&
errno != EAGAIN &&
errno != EINTR)
goto socket_error;
}
poll: Add general way to hook into mainloop without fd This adds a _cogl_poll_renderer_add_source() function that we can use within cogl to hook into the mainloop without necessarily having a file descriptor to poll. Since the intention is to use this to support polling for fence completions this also updates the CoglPollCheckCallback type to take a timeout pointer so sources can optionally update the timeout that will be passed to poll. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 81c1ce0ffce4e75e08622e20848405987e00b3cc)
2013-05-13 21:51:55 -04:00
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
if ((revents & COGL_POLL_FD_EVENT_OUT))
{
int ret = wl_display_flush (wayland_renderer->wayland_display);
wayland: Remove the Wayland socket FD if there are any errors Previously if the Wayland socket gets closed then Cogl would ignore the error when dispatching events which meant the socket would be constantly ready for reading, the main loop would never go idle and it would sit at 100% CPU. When Wayland encounters an error it will actually close the socket which means if something else opened another file then we might even end up polling on a completely unrelated FD. This patch makes it remove the FD from the main loop as soon as it hits an error so that it will at least avoid breaking the main loop. However I think most applications would probably want to abort in this case so we might also want to add a way to inform the application of this or even just abort directly. The cogl_poll_* functions have been changed so that they can cope if the pending and dispatch callbacks remove their own FD while they are invoked. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85857b10687a5a246a0a4ef42711e560c7a6f45d)
2013-07-09 08:39:11 -04:00
if (ret == -1)
{
if (errno != EAGAIN && errno != EINTR)
goto socket_error;
}
else
{
/* There is no more data to write so we don't need to wake
* up when the write buffer is emptied anymore */
_cogl_poll_renderer_modify_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN);
}
wayland: Always call wl_display_flush before going idle Previously Cogl would only call wl_display_flush after doing a swap buffers on the onscreen because that is the only place where Cogl itself would end up queueing requests. However since commit 323fe188748 Cogl takes control of calling wl_display_dispatch as well which effectively makes it very difficult for the application to handle the Wayland event queue itself. Therefore it needs to rely on Cogl to do it which means that other parts of the application may also queue requests that need to be flushed. This patch tries to copy the display fd handling of window.c in the Weston example clients. wl_display_flush will always be called in prepare function for the fd which means it will always be called before going idle. If flushing the display causes the socket buffer to become full, it will additionally poll for write on the FD to try flushing again when it becomes empty. We also need to call wl_display_dispatch_pending in the prepare because apparently calling eglSwapBuffers can cause it to read data from the FD to receive events for a different queue. In that case there will be events that need to be handled but the FD will no longer be ready for reading so we won't wake up the main loop any other way. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 962d1825105a87dd8358a765353b77f6af8fe760)
2013-06-28 07:19:20 -04:00
}
wayland: Remove the Wayland socket FD if there are any errors Previously if the Wayland socket gets closed then Cogl would ignore the error when dispatching events which meant the socket would be constantly ready for reading, the main loop would never go idle and it would sit at 100% CPU. When Wayland encounters an error it will actually close the socket which means if something else opened another file then we might even end up polling on a completely unrelated FD. This patch makes it remove the FD from the main loop as soon as it hits an error so that it will at least avoid breaking the main loop. However I think most applications would probably want to abort in this case so we might also want to add a way to inform the application of this or even just abort directly. The cogl_poll_* functions have been changed so that they can cope if the pending and dispatch callbacks remove their own FD while they are invoked. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 85857b10687a5a246a0a4ef42711e560c7a6f45d)
2013-07-09 08:39:11 -04:00
return;
socket_error:
/* If there was an error on the wayland socket then it's likely that
* it's going to consistently fail so we'll stop waiting on the file
* descriptor instead of making the application take up 100% CPU.
* FIXME: it would be nice if there was some way to report this to
* the application so that it can quit or recover */
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
Associate check and dispatch funcs with poll fds Instead of driving event dispatching through a per winsys poll_dispatch vfunc its now possible to associate a check and dispatch function with each file descriptor that is registered for polling. This means we can remove the winsys get_dispatch_timeout and poll_dispatch vfuncs and it also makes it easier for more orthogonal internal components to add file descriptors for polling to the mainloop. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 627947622df36dd529b9dc60a3ae9e6083532b19)
2013-04-18 11:26:21 -04:00
}
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
static CoglBool
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
CoglRendererEGL *egl_renderer;
CoglRendererWayland *wayland_renderer;
renderer->winsys = g_slice_new0 (CoglRendererEGL);
egl_renderer = renderer->winsys;
wayland_renderer = g_slice_new0 (CoglRendererWayland);
egl_renderer->platform = wayland_renderer;
egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable;
/* The EGL API doesn't provide for a way to explicitly select a
* platform when the driver can support multiple. Mesa allows
* selection using an environment variable though so that's what
* we're doing here... */
g_setenv ("EGL_PLATFORM", "wayland", 1);
if (renderer->foreign_wayland_display)
{
wayland_renderer->wayland_display = renderer->foreign_wayland_display;
}
else
{
wayland_renderer->wayland_display = wl_display_connect (NULL);
if (!wayland_renderer->wayland_display)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
COGL_WINSYS_ERROR_INIT,
"Failed to connect wayland display");
goto error;
}
Get rid of the foreign shell and compositor APIs The Wayland 1.0 protocol supports multiple independent components querying the available interfaces by retreiving their own wl_registry object so the application doesn't need to pass them down anymore. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8ca36a1d1ab7236fec0f4d7b7361ca96e14c32be)
2013-07-03 13:48:15 -04:00
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
Get rid of the foreign shell and compositor APIs The Wayland 1.0 protocol supports multiple independent components querying the available interfaces by retreiving their own wl_registry object so the application doesn't need to pass them down anymore. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8ca36a1d1ab7236fec0f4d7b7361ca96e14c32be)
2013-07-03 13:48:15 -04:00
wayland_renderer->wayland_registry =
wl_display_get_registry (wayland_renderer->wayland_display);
wayland: Port to new Wayland protocol Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit db50c3015c589375029a4c26c58db8295bb17bca)
2012-10-12 13:50:33 -04:00
Get rid of the foreign shell and compositor APIs The Wayland 1.0 protocol supports multiple independent components querying the available interfaces by retreiving their own wl_registry object so the application doesn't need to pass them down anymore. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 8ca36a1d1ab7236fec0f4d7b7361ca96e14c32be)
2013-07-03 13:48:15 -04:00
wl_registry_add_listener (wayland_renderer->wayland_registry,
&registry_listener,
egl_renderer);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
/*
* Ensure that that we've received the messages setting up the
* compostor and shell object. This is better than just
* wl_display_iterate since it will always ensure that something
* is available to be read
*/
while (!(wayland_renderer->wayland_compositor &&
wayland_renderer->wayland_shell))
wl_display_roundtrip (wayland_renderer->wayland_display);
egl_renderer->edpy =
eglGetDisplay ((EGLNativeDisplayType) wayland_renderer->wayland_display);
if (!_cogl_winsys_egl_renderer_connect_common (renderer, error))
goto error;
wayland: Add API to prevent Cogl from dispatching the wayland display This adds cogl_wayland_renderer_set_event_dispatch_enabled() which can be used to prevent Cogl from adding the socket for the Wayland display to its list of file descriptors to poll. This can be used in applications that want to integrate Cogl with existing code that is reading from the Wayland socket itself. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f5b8d98676ab3e90ad80459019c737ec2ff90aa4)
2013-07-04 08:14:04 -04:00
wayland_renderer->fd = wl_display_get_fd (wayland_renderer->wayland_display);
if (renderer->wayland_enable_event_dispatch)
_cogl_poll_renderer_add_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN,
prepare_wayland_display_events,
dispatch_wayland_display_events,
renderer);
wayland: implement poll_get_info and poll_dispatch Call wl_display_dispatch on POLLIN. This follows the implementation in weston/clients/window.c and improves integration of input events, at least. Signed-off-by: Andreas Oberritter <obi@saftware.de> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 323fe1887487f19c3e26aa6b7644de31d8d0a532)
2013-04-16 15:22:15 -04:00
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
return TRUE;
error:
_cogl_winsys_renderer_disconnect (renderer);
return FALSE;
}
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
static CoglBool
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
_cogl_winsys_egl_display_setup (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display;
wayland_display = g_slice_new0 (CoglDisplayWayland);
egl_display->platform = wayland_display;
return TRUE;
}
static void
_cogl_winsys_egl_display_destroy (CoglDisplay *display)
{
CoglDisplayEGL *egl_display = display->winsys;
g_slice_free (CoglDisplayWayland, egl_display->platform);
}
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
static CoglBool
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
_cogl_winsys_egl_context_created (CoglDisplay *display,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
const char *error_message;
wayland_display->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_display->wayland_surface)
{
error_message= "Failed to create a dummy wayland surface";
goto fail;
}
wayland_display->wayland_egl_native_window =
wl_egl_window_create (wayland_display->wayland_surface,
1,
1);
if (!wayland_display->wayland_egl_native_window)
{
error_message= "Failed to create a dummy wayland native egl surface";
goto fail;
}
egl_display->dummy_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(EGLNativeWindowType)
wayland_display->wayland_egl_native_window,
NULL);
if (egl_display->dummy_surface == EGL_NO_SURFACE)
{
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-05 22:21:30 -05:00
error_message= "Unable to create dummy window surface";
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
goto fail;
}
Adds initial GLES2 integration support This makes it possible to integrate existing GLES2 code with applications using Cogl as the rendering api. Currently all GLES2 usage is handled with separate GLES2 contexts to ensure that GLES2 api usage doesn't interfere with Cogl's own use of OpenGL[ES]. The api has been designed though so we can provide tighter integration later. The api would allow us to support GLES2 virtualized on top of an OpenGL/GLX driver as well as GLES2 virtualized on the core rendering api of Cogl itself. Virtualizing the GLES2 support on Cogl will allow us to take advantage of Cogl debugging facilities as well as let us optimize the cost of allocating multiple GLES2 contexts and switching between them which can both be very expensive with many drivers. As as a side effect of this patch Cogl can also now be used as a portable window system binding API for GLES2 as an alternative to EGL. Parts of this patch are based on work done by Tomeu Vizoso <tomeu.vizoso@collabora.com> who did the first iteration of adding GLES2 API support to Cogl so that WebGL support could be added to webkit-clutter. This patch adds a very minimal cogl-gles2-context example that shows how to create a gles2 context, clear the screen to a random color and also draw a triangle with the cogl api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 4bb6eff3dbd50d8fef7d6bdbed55c5aaa70036a8)
2012-03-05 22:21:30 -05:00
if (!_cogl_winsys_egl_make_current (display,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->egl_context))
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
error_message = "Unable to eglMakeCurrent with dummy surface";
goto fail;
}
return TRUE;
fail:
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"%s", error_message);
return FALSE;
}
static void
_cogl_winsys_egl_cleanup_context (CoglDisplay *display)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
if (egl_display->dummy_surface != EGL_NO_SURFACE)
{
eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface);
egl_display->dummy_surface = EGL_NO_SURFACE;
}
if (wayland_display->wayland_egl_native_window)
{
wl_egl_window_destroy (wayland_display->wayland_egl_native_window);
wayland_display->wayland_egl_native_window = NULL;
}
if (wayland_display->wayland_surface)
{
wl_surface_destroy (wayland_display->wayland_surface);
wayland_display->wayland_surface = NULL;
}
}
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
static CoglBool
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
_cogl_winsys_egl_context_init (CoglContext *context,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
context->feature_flags |= COGL_FEATURE_ONSCREEN_MULTIPLE;
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_ONSCREEN_MULTIPLE, TRUE);
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN,
TRUE);
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT,
TRUE);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05: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
/* We'll manually handle queueing dirty events when the surface is
* first shown or when it is resized. Note that this is slightly
* different from the emulated behaviour that CoglFramebuffer would
* provide if we didn't set this flag because we want to emit the
* event on show instead of on allocation. The Wayland protocol
* delays setting the surface type until the next buffer is attached
* so attaching a buffer before setting the type would not cause
* anything to be displayed */
context->private_feature_flags |= COGL_PRIVATE_FEATURE_DIRTY_EVENTS;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
return TRUE;
}
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
static CoglBool
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
CoglError **error)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen;
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland_onscreen = g_slice_new0 (CoglOnscreenWayland);
egl_onscreen->platform = wayland_onscreen;
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
_cogl_list_init (&wayland_onscreen->frame_callbacks);
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
if (onscreen->foreign_surface)
wayland_onscreen->wayland_surface = onscreen->foreign_surface;
else
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
if (!wayland_onscreen->wayland_surface)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
wayland_onscreen->wayland_egl_native_window =
wl_egl_window_create (wayland_onscreen->wayland_surface,
cogl_framebuffer_get_width (framebuffer),
cogl_framebuffer_get_height (framebuffer));
if (!wayland_onscreen->wayland_egl_native_window)
{
Adds CoglError api Although we use GLib internally in Cogl we would rather not leak GLib api through Cogl's own api, except through explicitly namespaced cogl_glib_ / cogl_gtype_ feature apis. One of the benefits we see to not leaking GLib through Cogl's public API is that documentation for Cogl won't need to first introduce the Glib API to newcomers, thus hopefully lowering the barrier to learning Cogl. This patch provides a Cogl specific typedef for reporting runtime errors which by no coincidence matches the typedef for GError exactly. If Cogl is built with --enable-glib (default) then developers can even safely assume that a CoglError is a GError under the hood. This patch also enforces a consistent policy for when NULL is passed as an error argument and an error is thrown. In this case we log the error and abort the application, instead of silently ignoring it. In common cases where nothing has been implemented to handle a particular error and/or where applications are just printing the error and aborting themselves then this saves some typing. This also seems more consistent with language based exceptions which usually cause a program to abort if they are not explicitly caught (which passing a non-NULL error signifies in this case) Since this policy for NULL error pointers is stricter than the standard GError convention, there is a clear note in the documentation to warn developers that are used to using the GError api. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit b068d5ea09ab32c37e8c965fc8582c85d1b2db46) Note: Since we can't change the Cogl 1.x api the patch was changed to not rename _error_quark() functions to be _error_domain() functions and although it's a bit ugly, instead of providing our own CoglError type that's compatible with GError we simply #define CoglError to GError unless Cogl is built with glib disabled. Note: this patch does technically introduce an API break since it drops the cogl_error_get_type() symbol generated by glib-mkenum (Since the CoglError enum was replaced by a CoglSystemError enum) but for now we are assuming that this will not affect anyone currently using the Cogl API. If this does turn out to be a problem in practice then we would be able to fix this my manually copying an implementation of cogl_error_get_type() generated by glib-mkenum into a compatibility source file and we could also define the original COGL_ERROR_ enums for compatibility too. Note: another minor concern with cherry-picking this patch to the 1.14 branch is that an api scanner would be lead to believe that some APIs have changed, and for example the gobject-introspection parser which understands the semantics of GError will not understand the semantics of CoglError. We expect most people that have tried to use gobject-introspection with Cogl already understand though that it is not well suited to generating bindings of the Cogl api anyway and we aren't aware or anyone depending on such bindings for apis involving GErrors. (GnomeShell only makes very-very minimal use of Cogl via the gjs bindings for the cogl_rectangle and cogl_color apis.) The main reason we have cherry-picked this patch to the 1.14 branch even given the above concerns is that without it it would become very awkward for us to cherry-pick other beneficial patches from master.
2012-08-31 14:28:27 -04:00
_cogl_set_error (error, COGL_WINSYS_ERROR,
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland egl native window "
"for CoglOnscreen");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_config,
(EGLNativeWindowType)
wayland_onscreen->wayland_egl_native_window,
NULL);
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
if (!onscreen->foreign_surface)
wayland: Don't set the surface to toplevel until it is shown If we delay setting the surface to toplevel until it is shown then that gives the application an opportunity to avoid calling show so that it can set its own surface type. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ab59c3a421968d7f159d89ca2f0ba8a9f098cbf6)
2013-05-15 11:34:15 -04:00
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
return TRUE;
}
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
static void
free_frame_callback_data (FrameCallbackData *callback_data)
{
cogl_object_unref (callback_data->frame_info);
wl_callback_destroy (callback_data->callback);
_cogl_list_remove (&callback_data->link);
g_slice_free (FrameCallbackData, callback_data);
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
static void
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
FrameCallbackData *frame_callback_data, *tmp;
_cogl_list_for_each_safe (frame_callback_data,
tmp,
&wayland_onscreen->frame_callbacks,
link)
free_frame_callback_data (frame_callback_data);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
if (wayland_onscreen->wayland_egl_native_window)
{
wl_egl_window_destroy (wayland_onscreen->wayland_egl_native_window);
wayland_onscreen->wayland_egl_native_window = NULL;
}
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
if (!onscreen->foreign_surface)
wayland: free framebuffer's shell surface on destroy This prevents leaking the Wayland shell surface associated with a Cogl OnScreen when it is finalised. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 760fc9f3af5475530262b82a55df311fceca358a)
2013-04-26 10:04:36 -04:00
{
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
/* NB: The wayland protocol docs explicitly state that
* "wl_shell_surface_destroy() must be called before destroying
* the wl_surface object." ... */
if (wayland_onscreen->wayland_shell_surface)
{
wl_shell_surface_destroy (wayland_onscreen->wayland_shell_surface);
wayland_onscreen->wayland_shell_surface = NULL;
}
wayland: free framebuffer's shell surface on destroy This prevents leaking the Wayland shell surface associated with a Cogl OnScreen when it is finalised. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 760fc9f3af5475530262b82a55df311fceca358a)
2013-04-26 10:04:36 -04:00
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
if (wayland_onscreen->wayland_surface)
{
wl_surface_destroy (wayland_onscreen->wayland_surface);
wayland_onscreen->wayland_surface = NULL;
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
}
g_slice_free (CoglOnscreenWayland, wayland_onscreen);
}
static void
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
flush_pending_resize (CoglOnscreen *onscreen)
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
{
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
if (wayland_onscreen->has_pending)
{
wl_egl_window_resize (wayland_onscreen->wayland_egl_native_window,
wayland_onscreen->pending_width,
wayland_onscreen->pending_height,
wayland_onscreen->pending_dx,
wayland_onscreen->pending_dy);
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
_cogl_framebuffer_winsys_update_size (COGL_FRAMEBUFFER (onscreen),
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
wayland_onscreen->pending_width,
wayland_onscreen->pending_height);
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -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
_cogl_onscreen_queue_full_dirty (onscreen);
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
wayland_onscreen->pending_dx = 0;
wayland_onscreen->pending_dy = 0;
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
wayland_onscreen->has_pending = FALSE;
}
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
}
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
static void
frame_cb (void *data,
struct wl_callback *callback,
uint32_t time)
{
FrameCallbackData *callback_data = data;
CoglFrameInfo *info = callback_data->frame_info;
CoglOnscreen *onscreen = callback_data->onscreen;
g_assert (callback_data->callback == callback);
_cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_SYNC, info);
_cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_COMPLETE, info);
free_frame_callback_data (callback_data);
}
static const struct wl_callback_listener
frame_listener =
{
frame_cb
};
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
static void
_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
const int *rectangles,
int n_rectangles)
{
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
FrameCallbackData *frame_callback_data = g_slice_new (FrameCallbackData);
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
flush_pending_resize (onscreen);
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
wayland: Send COGL_FRAME_EVENT_SYNC based on the frame callback Instead of queuing the frame sync event immediately after a swap, the Wayland winsys now installs a frame callback and queues the event when Wayland reports that the frame is complete. It also reports the COGL_FRAME_EVENT_COMPLETE event at the same time because there is no more information we can give. This patch is a bit of a divergence from how the events are handled in the GLX winsys. Instead of installing its own idle function, the _cogl_onscreen_queue_event() function has now been made non-static so that it can be used by the Wayland winsys. The frame callback now just queues an event using that. The pending_frame_infos queue on the CoglOnscreen isn't used and instead the CoglFrameInfo is immediately popped off the queue so that it can be stored as part of the closure data when the frame callback is set up. That way it would use the right frame info even if somehow the Wayland callbacks were invoked in the wrong order and the code is a bit simpler. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f7ea370a0d5013c9f0263f37c7f892adc8a2f087)
2013-07-09 13:16:18 -04:00
/* Before calling the winsys function,
* cogl_onscreen_swap_buffers_with_damage() will have pushed the
* frame info object onto the end of the pending frames. We can grab
* it out of the queue now because we don't care about the order and
* we will just directly queue the event corresponding to the exact
* frame that Wayland reports as completed. This will steal the
* reference */
frame_callback_data->frame_info =
g_queue_pop_tail (&onscreen->pending_frame_infos);
frame_callback_data->onscreen = onscreen;
frame_callback_data->callback =
wl_surface_frame (wayland_onscreen->wayland_surface);
wl_callback_add_listener (frame_callback_data->callback,
&frame_listener,
frame_callback_data);
_cogl_list_insert (&wayland_onscreen->frame_callbacks,
&frame_callback_data->link);
onscreen: Adds swap_buffers_with_damage api This adds api to be able requests a swap_buffers and also pass a list of damage rectangles that can be passed on to a compositor to enable it to minimize how much of the screen it needs to recompose. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0d9684c7b7c2018bb42715c369555330d38514a2)
2012-02-07 12:59:51 -05:00
parent_vtable->onscreen_swap_buffers_with_damage (onscreen,
rectangles,
n_rectangles);
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
}
wayland: Don't set the surface to toplevel until it is shown If we delay setting the surface to toplevel until it is shown then that gives the application an opportunity to avoid calling show so that it can set its own surface type. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ab59c3a421968d7f159d89ca2f0ba8a9f098cbf6)
2013-05-15 11:34:15 -04:00
static void
_cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
CoglBool visibility)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
/* The first time the onscreen is shown we will set it to toplevel
* so that it will appear on the screen. If the surface is foreign
* then we won't have the shell surface and we'll just let the
* application deal with setting the surface type. */
if (visibility &&
wayland_onscreen->wayland_shell_surface &&
!wayland_onscreen->shell_surface_type_set)
{
wl_shell_surface_set_toplevel (wayland_onscreen->wayland_shell_surface);
wayland_onscreen->shell_surface_type_set = TRUE;
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_full_dirty (onscreen);
wayland: Don't set the surface to toplevel until it is shown If we delay setting the surface to toplevel until it is shown then that gives the application an opportunity to avoid calling show so that it can set its own surface type. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ab59c3a421968d7f159d89ca2f0ba8a9f098cbf6)
2013-05-15 11:34:15 -04:00
}
/* FIXME: We should also do something here to hide the surface when
* visilibity == FALSE. It sounds like there are currently ongoing
* discussions about adding support for hiding surfaces in the
* Wayland protocol so we might as well wait until then to add that
* here. */
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
void
cogl_wayland_renderer_set_foreign_display (CoglRenderer *renderer,
struct wl_display *display)
{
_COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer));
/* NB: Renderers are considered immutable once connected */
_COGL_RETURN_IF_FAIL (!renderer->connected);
renderer->foreign_wayland_display = display;
}
wayland: Add API to prevent Cogl from dispatching the wayland display This adds cogl_wayland_renderer_set_event_dispatch_enabled() which can be used to prevent Cogl from adding the socket for the Wayland display to its list of file descriptors to poll. This can be used in applications that want to integrate Cogl with existing code that is reading from the Wayland socket itself. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f5b8d98676ab3e90ad80459019c737ec2ff90aa4)
2013-07-04 08:14:04 -04:00
void
cogl_wayland_renderer_set_event_dispatch_enabled (CoglRenderer *renderer,
CoglBool enable)
{
_COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer));
/* NB: Renderers are considered immutable once connected */
_COGL_RETURN_IF_FAIL (!renderer->connected);
renderer->wayland_enable_event_dispatch = enable;
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
struct wl_display *
cogl_wayland_renderer_get_display (CoglRenderer *renderer)
{
_COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL);
if (renderer->foreign_wayland_display)
return renderer->foreign_wayland_display;
else if (renderer->connected)
{
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
return wayland_renderer->wayland_display;
}
else
return NULL;
}
struct wl_surface *
cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen)
{
Implicitly allocate on cogl_wayland_onscreen_get_(shell_)?surface The idea with the framebuffer allocation is that it will lazily allocate so that if you don't want to handle errors then you don't have to be aware that there is an allocation step. In order for this to work any accessors that get data that is only available after allocation should implicitly allocate the framebuffer. This patch makes that change for cogl_wayland_onscreen_get_surface and cogl_wayland_onscreen_get_shell_surface. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0c4ba78787323fedd162d7b71b86b460908b9b98)
2013-07-03 13:32:00 -04:00
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenWayland *wayland_onscreen;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
Implicitly allocate on cogl_wayland_onscreen_get_(shell_)?surface The idea with the framebuffer allocation is that it will lazily allocate so that if you don't want to handle errors then you don't have to be aware that there is an allocation step. In order for this to work any accessors that get data that is only available after allocation should implicitly allocate the framebuffer. This patch makes that change for cogl_wayland_onscreen_get_surface and cogl_wayland_onscreen_get_shell_surface. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0c4ba78787323fedd162d7b71b86b460908b9b98)
2013-07-03 13:32:00 -04:00
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL);
egl_onscreen = onscreen->winsys;
wayland_onscreen = egl_onscreen->platform;
return wayland_onscreen->wayland_surface;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
}
struct wl_shell_surface *
cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen)
{
Implicitly allocate on cogl_wayland_onscreen_get_(shell_)?surface The idea with the framebuffer allocation is that it will lazily allocate so that if you don't want to handle errors then you don't have to be aware that there is an allocation step. In order for this to work any accessors that get data that is only available after allocation should implicitly allocate the framebuffer. This patch makes that change for cogl_wayland_onscreen_get_surface and cogl_wayland_onscreen_get_shell_surface. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0c4ba78787323fedd162d7b71b86b460908b9b98)
2013-07-03 13:32:00 -04:00
CoglOnscreenEGL *egl_onscreen;
CoglOnscreenWayland *wayland_onscreen;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
Implicitly allocate on cogl_wayland_onscreen_get_(shell_)?surface The idea with the framebuffer allocation is that it will lazily allocate so that if you don't want to handle errors then you don't have to be aware that there is an allocation step. In order for this to work any accessors that get data that is only available after allocation should implicitly allocate the framebuffer. This patch makes that change for cogl_wayland_onscreen_get_surface and cogl_wayland_onscreen_get_shell_surface. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0c4ba78787323fedd162d7b71b86b460908b9b98)
2013-07-03 13:32:00 -04:00
cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL);
egl_onscreen = onscreen->winsys;
wayland_onscreen = egl_onscreen->platform;
return wayland_onscreen->wayland_shell_surface;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
}
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
void
cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen,
struct wl_surface *surface)
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
_COGL_RETURN_IF_FAIL (!fb->allocated);
onscreen->foreign_surface = surface;
}
wayland: Add a cogl_wayland_onscreen_resize function This function will call into the Wayland EGL platform API and resize the surface that the window is using and update the internal dimensions for framebuffer and viewport to reflect the change. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-12 09:49:27 -05:00
void
cogl_wayland_onscreen_resize (CoglOnscreen *onscreen,
Swaps a few uses of gint for int We've avoiding using the redundant glib typedefs such as guint, gint gpointer etc and prefer to use the equivalent C types so this patch removes a few uses of gint that slipped past review.
2012-01-16 06:40:00 -05:00
int width,
int height,
int offset_x,
int offset_y)
wayland: Add a cogl_wayland_onscreen_resize function This function will call into the Wayland EGL platform API and resize the surface that the window is using and update the internal dimensions for framebuffer and viewport to reflect the change. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-12 09:49:27 -05:00
{
CoglFramebuffer *fb;
fb = COGL_FRAMEBUFFER (onscreen);
if (fb->allocated)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
if (cogl_framebuffer_get_width (fb) != width ||
cogl_framebuffer_get_height (fb) != height ||
offset_x ||
offset_y)
{
wayland_onscreen->pending_width = width;
wayland_onscreen->pending_height = height;
wayland_onscreen->pending_dx += offset_x;
wayland_onscreen->pending_dy += offset_y;
wayland_onscreen->has_pending = TRUE;
wayland: Don't delay resize if nothing is drawn since last swap After discussing with Kristian Høgsberg it seems that the semantics of wl_egl_window_resize is meant to be that if nothing has been drawn to the framebuffer since the last swap then the resize will take effect immediately. Cogl was previously always delaying the call to wl_egl_window_resize until the next swap. That meant that if you wanted to resize the surface you would have to call cogl_wayland_onscreen_resize and then redundantly draw a frame at the old size so that you can swap to get the resize to occur before drawing again at the right size. Typically an application would decide to resize at the start of its paint sequence so it should be able to just resize immediately. In current Mesa master it seems that there is a bug which means that it won't actually delay a resize that is done mid-scene and instead it will just discard what came before. To get consistent behaviour in Cogl, the code to delay the call to wl_egl_window_resize is still used if it determines that the buffer is dirty. There is an existing _cogl_framebuffer_mark_mid_scene call which was being used to track when the framebuffer becomes dirty since the last clear. This function is now also used to track a new flag to track whether something has been drawn since the last swap. It is called ‘mid_scene’ under the assumption that this may also be useful for other things later. cogl_framebuffer_clear has been slightly altered to always call _cogl_framebuffer_mark_mid_scene even if it determines that it doesn't need to clear because the framebuffer should still be considered to be in the middle of a scene. Adding a quad to the journal now also begins the scene. This also fixes a potential bug where it looks like pending_dx/dy were never cleared so they would always be accumulated even after the resize is flushed. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 945689a62903990a20abb87a85d2c96eb3985fe7)
2013-05-17 10:13:41 -04:00
/* If nothing has been drawn to the framebuffer since the
* last swap then wl_egl_window_resize will take effect
* immediately. Otherwise it might not take effect until the
* next swap, depending on the version of Mesa. To keep
* consistent behaviour we'll delay the resize until the
* next swap unless we're sure nothing has been drawn */
if (!fb->mid_scene)
flush_pending_resize (onscreen);
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
}
wayland: Add a cogl_wayland_onscreen_resize function This function will call into the Wayland EGL platform API and resize the surface that the window is using and update the internal dimensions for framebuffer and viewport to reflect the change. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-12 09:49:27 -05:00
}
wayland: perform buffer resizes lazily at swap buffers Resizing a wayland client framebuffer should not affect the viewport of additional primitives drawn to that framebuffer before the next swap buffers request nor should querying the framebuffer's width and height be affected until the next swap buffers request completes. This patch changes cogl_wayland_onscreen_resize() so it only saves the new geometry as "pending" state internal to the given CoglOnscreen. Only when cogl_framebuffer_swap_buffers() is next called will the pending size be flushed to the wayland egl api.
2012-01-16 07:30:06 -05:00
else
_cogl_framebuffer_winsys_update_size (fb, width, height);
wayland: Add a cogl_wayland_onscreen_resize function This function will call into the Wayland EGL platform API and resize the surface that the window is using and update the internal dimensions for framebuffer and viewport to reflect the change. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2012-01-12 09:49:27 -05:00
}
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
static const CoglWinsysEGLVtable
_cogl_winsys_egl_vtable =
{
.display_setup = _cogl_winsys_egl_display_setup,
.display_destroy = _cogl_winsys_egl_display_destroy,
.context_created = _cogl_winsys_egl_context_created,
.cleanup_context = _cogl_winsys_egl_cleanup_context,
.context_init = _cogl_winsys_egl_context_init,
.onscreen_init = _cogl_winsys_egl_onscreen_init,
.onscreen_deinit = _cogl_winsys_egl_onscreen_deinit
};
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
const CoglWinsysVtable *
_cogl_winsys_egl_wayland_get_vtable (void)
{
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
static CoglBool vtable_inited = FALSE;
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
static CoglWinsysVtable vtable;
if (!vtable_inited)
{
/* The EGL_WAYLAND winsys is a subclass of the EGL winsys so we
start by copying its vtable */
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
parent_vtable = _cogl_winsys_egl_get_vtable ();
vtable = *parent_vtable;
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
vtable.id = COGL_WINSYS_ID_EGL_WAYLAND;
vtable.name = "EGL_WAYLAND";
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
vtable.renderer_connect = _cogl_winsys_renderer_connect;
vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect;
onscreen: Adds swap_buffers_with_damage api This adds api to be able requests a swap_buffers and also pass a list of damage rectangles that can be passed on to a compositor to enable it to minimize how much of the screen it needs to recompose. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 0d9684c7b7c2018bb42715c369555330d38514a2)
2012-02-07 12:59:51 -05:00
vtable.onscreen_swap_buffers_with_damage =
_cogl_winsys_onscreen_swap_buffers_with_damage;
winsys: Move Wayland-specific code out of the EGL winsys All of the Wayland-specific code now lives in the EGL_WAYLAND winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-12 12:31:27 -05:00
wayland: Don't set the surface to toplevel until it is shown If we delay setting the surface to toplevel until it is shown then that gives the application an opportunity to avoid calling show so that it can set its own surface type. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ab59c3a421968d7f159d89ca2f0ba8a9f098cbf6)
2013-05-15 11:34:15 -04:00
vtable.onscreen_set_visibility =
_cogl_winsys_onscreen_set_visibility;
Add a separate winsys vtable for each EGL platform Instead of just having an "EGL" renderer, there is now a separate winsys for each platform. Currently they just directly copy the vtable for the EGL platform so it is still only possible to have one EGL platform compiled into Cogl. However the intention is that the winsys-specific code for each platform will be moved into override functions in the corresponding platform winsys. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-12-08 12:24:40 -05:00
vtable_inited = TRUE;
}
return &vtable;
}
Reference in New Issue Copy Permalink