From 4dbef01ec35ecdd02d06bdf70f1fd4aa5cb389ac Mon Sep 17 00:00:00 2001 From: Neil Roberts Date: Mon, 12 Dec 2011 17:31:27 +0000 Subject: [PATCH] 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 --- cogl/winsys/cogl-winsys-egl-private.h | 20 -- cogl/winsys/cogl-winsys-egl-wayland.c | 487 +++++++++++++++++++++++++- cogl/winsys/cogl-winsys-egl.c | 342 +----------------- 3 files changed, 489 insertions(+), 360 deletions(-) diff --git a/cogl/winsys/cogl-winsys-egl-private.h b/cogl/winsys/cogl-winsys-egl-private.h index 95fc011b2..9a0a64368 100644 --- a/cogl/winsys/cogl-winsys-egl-private.h +++ b/cogl/winsys/cogl-winsys-egl-private.h @@ -28,10 +28,6 @@ #include "cogl-winsys-private.h" #include "cogl-context.h" #include "cogl-context-private.h" -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -#include -#include -#endif typedef struct _CoglWinsysEGLVtable { @@ -81,12 +77,6 @@ typedef struct _CoglRendererEGL { CoglEGLWinsysFeature private_features; -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - struct wl_display *wayland_display; - struct wl_compositor *wayland_compositor; - struct wl_shell *wayland_shell; -#endif - EGLDisplay edpy; EGLint egl_version_major; @@ -120,10 +110,6 @@ typedef struct _CoglDisplayEGL { EGLContext egl_context; EGLSurface dummy_surface; -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - struct wl_surface *wayland_surface; - struct wl_egl_window *wayland_egl_native_window; -#endif #if defined (COGL_HAS_EGL_PLATFORM_POWERVR_NULL_SUPPORT) || \ defined (COGL_HAS_EGL_PLATFORM_GDL_SUPPORT) || \ defined (COGL_HAS_EGL_PLATFORM_ANDROID_SUPPORT) || \ @@ -149,12 +135,6 @@ typedef struct _CoglContextEGL typedef struct _CoglOnscreenEGL { -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - struct wl_egl_window *wayland_egl_native_window; - struct wl_surface *wayland_surface; - struct wl_shell_surface *wayland_shell_surface; -#endif - EGLSurface egl_surface; /* Platform specific data */ diff --git a/cogl/winsys/cogl-winsys-egl-wayland.c b/cogl/winsys/cogl-winsys-egl-wayland.c index cb4766e80..0b7ff2602 100644 --- a/cogl/winsys/cogl-winsys-egl-wayland.c +++ b/cogl/winsys/cogl-winsys-egl-wayland.c @@ -29,8 +29,487 @@ #include "config.h" #endif +#include +#include +#include + #include "cogl-winsys-egl-wayland-private.h" #include "cogl-winsys-egl-private.h" +#include "cogl-renderer-private.h" +#include "cogl-onscreen-private.h" + +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; +} 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; +} CoglOnscreenWayland; + +static void +display_handle_global_cb (struct wl_display *display, + uint32_t id, + const char *interface, + uint32_t version, + void *data) +{ + CoglRendererEGL *egl_renderer = (CoglRendererEGL *)data; + CoglRendererWayland *wayland_renderer = egl_renderer->platform; + + if (strcmp (interface, "wl_compositor") == 0) + wayland_renderer->wayland_compositor = + wl_display_bind (display, id, &wl_compositor_interface); + else if (strcmp(interface, "wl_shell") == 0) + wayland_renderer->wayland_shell = + wl_display_bind (display, id, &wl_shell_interface); +} + +static void +_cogl_winsys_renderer_disconnect (CoglRenderer *renderer) +{ + CoglRendererEGL *egl_renderer = renderer->winsys; + + eglTerminate (egl_renderer->edpy); + + g_slice_free (CoglRendererWayland, egl_renderer->platform); + g_slice_free (CoglRendererEGL, egl_renderer); +} + +static gboolean +_cogl_winsys_renderer_connect (CoglRenderer *renderer, + GError **error) +{ + 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; + /* XXX: For now we have to assume that if a foreign display is + * given then a foreign compositor and shell must also have been + * given because wayland doesn't provide a way to + * retrospectively be notified of the these objects. */ + g_assert (renderer->foreign_wayland_compositor); + g_assert (renderer->foreign_wayland_shell); + wayland_renderer->wayland_compositor = + renderer->foreign_wayland_compositor; + wayland_renderer->wayland_shell = renderer->foreign_wayland_shell; + } + else + { + wayland_renderer->wayland_display = wl_display_connect (NULL); + if (!wayland_renderer->wayland_display) + { + g_set_error (error, COGL_WINSYS_ERROR, + COGL_WINSYS_ERROR_INIT, + "Failed to connect wayland display"); + goto error; + } + + wl_display_add_global_listener (wayland_renderer->wayland_display, + display_handle_global_cb, + egl_renderer); + } + + /* + * 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; + + return TRUE; + +error: + _cogl_winsys_renderer_disconnect (renderer); + return FALSE; +} + +static gboolean +_cogl_winsys_egl_display_setup (CoglDisplay *display, + GError **error) +{ + 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); +} + +static gboolean +_cogl_winsys_egl_context_created (CoglDisplay *display, + GError **error) +{ + 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) + { + error_message= "Unable to eglMakeCurrent with dummy surface"; + goto fail; + } + + if (!eglMakeCurrent (egl_renderer->edpy, + egl_display->dummy_surface, + egl_display->dummy_surface, + egl_display->egl_context)) + { + error_message = "Unable to eglMakeCurrent with dummy surface"; + goto fail; + } + + return TRUE; + + fail: + g_set_error (error, COGL_WINSYS_ERROR, + 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; + } +} + +static gboolean +_cogl_winsys_egl_context_init (CoglContext *context, + GError **error) +{ + 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); + + return TRUE; +} + +static gboolean +_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen, + EGLConfig egl_config, + GError **error) +{ + 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_onscreen->wayland_surface = + wl_compositor_create_surface (wayland_renderer->wayland_compositor); + if (!wayland_onscreen->wayland_surface) + { + g_set_error (error, COGL_WINSYS_ERROR, + COGL_WINSYS_ERROR_CREATE_ONSCREEN, + "Error while creating wayland surface for CoglOnscreen"); + return FALSE; + } + + wayland_onscreen->wayland_shell_surface = + wl_shell_get_shell_surface (wayland_renderer->wayland_shell, + wayland_onscreen->wayland_surface); + + 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) + { + g_set_error (error, COGL_WINSYS_ERROR, + 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); + + wl_shell_surface_set_toplevel (wayland_onscreen->wayland_shell_surface); + + return TRUE; +} + +static void +_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen) +{ + CoglOnscreenEGL *egl_onscreen = onscreen->winsys; + CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; + + if (wayland_onscreen->wayland_egl_native_window) + { + wl_egl_window_destroy (wayland_onscreen->wayland_egl_native_window); + wayland_onscreen->wayland_egl_native_window = NULL; + } + + if (wayland_onscreen->wayland_surface) + { + wl_surface_destroy (wayland_onscreen->wayland_surface); + wayland_onscreen->wayland_surface = NULL; + } + + g_slice_free (CoglOnscreenWayland, wayland_onscreen); +} + +static void +_cogl_winsys_onscreen_swap_buffers (CoglOnscreen *onscreen) +{ + CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context; + CoglRenderer *renderer = context->display->renderer; + CoglRendererEGL *egl_renderer = renderer->winsys; + CoglRendererWayland *wayland_renderer = egl_renderer->platform; + + /* First chain-up */ + parent_vtable->onscreen_swap_buffers (onscreen); + + /* + * The implementation of eglSwapBuffers may do a flush however the semantics + * of eglSwapBuffers on Wayland has changed in the past. So to be safe to + * the implementation changing we should explicitly ensure all messages are + * sent. + */ + wl_display_flush (wayland_renderer->wayland_display); +} + +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; +} + +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; +} + +void +cogl_wayland_renderer_set_foreign_compositor (CoglRenderer *renderer, + struct wl_compositor *compositor) +{ + _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); + + /* NB: Renderers are considered immutable once connected */ + _COGL_RETURN_IF_FAIL (!renderer->connected); + + renderer->foreign_wayland_compositor = compositor; +} + +struct wl_compositor * +cogl_wayland_renderer_get_compositor (CoglRenderer *renderer) +{ + _COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL); + + if (renderer->foreign_wayland_compositor) + return renderer->foreign_wayland_compositor; + else if (renderer->connected) + { + CoglRendererEGL *egl_renderer = renderer->winsys; + CoglRendererWayland *wayland_renderer = egl_renderer->platform; + return wayland_renderer->wayland_compositor; + } + else + return NULL; +} + +void +cogl_wayland_renderer_set_foreign_shell (CoglRenderer *renderer, + struct wl_shell *shell) +{ + _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); + + /* NB: Renderers are considered immutable once connected */ + _COGL_RETURN_IF_FAIL (!renderer->connected); + + renderer->foreign_wayland_shell = shell; +} + +struct wl_shell * +cogl_wayland_renderer_get_shell (CoglRenderer *renderer) +{ + _COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL); + + if (renderer->foreign_wayland_shell) + return renderer->foreign_wayland_shell; + else if (renderer->connected) + { + CoglRendererEGL *egl_renderer = renderer->winsys; + CoglRendererWayland *wayland_renderer = egl_renderer->platform; + return wayland_renderer->wayland_shell; + } + else + return NULL; +} + +struct wl_surface * +cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen) +{ + CoglFramebuffer *fb; + + fb = COGL_FRAMEBUFFER (onscreen); + if (fb->allocated) + { + CoglOnscreenEGL *egl_onscreen = onscreen->winsys; + CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; + return wayland_onscreen->wayland_surface; + } + else + return NULL; +} + +struct wl_shell_surface * +cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen) +{ + CoglFramebuffer *fb; + + fb = COGL_FRAMEBUFFER (onscreen); + if (fb->allocated) + { + CoglOnscreenEGL *egl_onscreen = onscreen->winsys; + CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; + return wayland_onscreen->wayland_shell_surface; + } + else + return NULL; +} + +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 + }; const CoglWinsysVtable * _cogl_winsys_egl_wayland_get_vtable (void) @@ -43,11 +522,17 @@ _cogl_winsys_egl_wayland_get_vtable (void) /* The EGL_WAYLAND winsys is a subclass of the EGL winsys so we start by copying its vtable */ - vtable = *_cogl_winsys_egl_get_vtable (); + parent_vtable = _cogl_winsys_egl_get_vtable (); + vtable = *parent_vtable; vtable.id = COGL_WINSYS_ID_EGL_WAYLAND; vtable.name = "EGL_WAYLAND"; + vtable.renderer_connect = _cogl_winsys_renderer_connect; + vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect; + + vtable.onscreen_swap_buffers = _cogl_winsys_onscreen_swap_buffers; + vtable_inited = TRUE; } diff --git a/cogl/winsys/cogl-winsys-egl.c b/cogl/winsys/cogl-winsys-egl.c index 674f5f6a0..c658fbca6 100644 --- a/cogl/winsys/cogl-winsys-egl.c +++ b/cogl/winsys/cogl-winsys-egl.c @@ -43,11 +43,6 @@ #include "cogl-private.h" -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -#include -#include -#endif - #ifdef COGL_HAS_EGL_PLATFORM_ANDROID_SUPPORT #include #endif @@ -137,27 +132,6 @@ _cogl_winsys_renderer_disconnect (CoglRenderer *renderer) g_slice_free (CoglRendererEGL, egl_renderer); } -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - -static void -display_handle_global_cb (struct wl_display *display, - uint32_t id, - const char *interface, - uint32_t version, - void *data) -{ - CoglRendererEGL *egl_renderer = (CoglRendererEGL *)data; - - if (strcmp (interface, "wl_compositor") == 0) - egl_renderer->wayland_compositor = - wl_display_bind (display, id, &wl_compositor_interface); - else if (strcmp(interface, "wl_shell") == 0) - egl_renderer->wayland_shell = - wl_display_bind (display, id, &wl_shell_interface); -} - -#endif - /* Updates all the function pointers */ static void check_egl_extensions (CoglRenderer *renderer) @@ -224,57 +198,6 @@ _cogl_winsys_renderer_connect (CoglRenderer *renderer, g_warn_if_reached (); goto error; -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - case COGL_WINSYS_ID_EGL_WAYLAND: - /* 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... */ - setenv("EGL_PLATFORM", "wayland", 1); - - if (renderer->foreign_wayland_display) - { - egl_renderer->wayland_display = renderer->foreign_wayland_display; - /* XXX: For now we have to assume that if a foreign display is - * given then a foreign compositor and shell must also have been - * given because wayland doesn't provide a way to - * retrospectively be notified of the these objects. */ - g_assert (renderer->foreign_wayland_compositor); - g_assert (renderer->foreign_wayland_shell); - egl_renderer->wayland_compositor = - renderer->foreign_wayland_compositor; - egl_renderer->wayland_shell = renderer->foreign_wayland_shell; - } - else - { - egl_renderer->wayland_display = wl_display_connect (NULL); - if (!egl_renderer->wayland_display) - { - g_set_error (error, COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_INIT, - "Failed to connect wayland display"); - goto error; - } - - wl_display_add_global_listener (egl_renderer->wayland_display, - display_handle_global_cb, - egl_renderer); - } - - /* - * 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 (!(egl_renderer->wayland_compositor && egl_renderer->wayland_shell)) - wl_display_roundtrip (egl_renderer->wayland_display); - - egl_renderer->edpy = - eglGetDisplay ((EGLNativeDisplayType)egl_renderer->wayland_display); - break; -#endif - case COGL_WINSYS_ID_EGL_GDL: case COGL_WINSYS_ID_EGL_ANDROID: case COGL_WINSYS_ID_EGL_NULL: @@ -458,49 +381,6 @@ try_create_context (CoglDisplay *display, return FALSE; break; -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - case COGL_WINSYS_ID_EGL_WAYLAND: - egl_display->wayland_surface = - wl_compositor_create_surface (egl_renderer->wayland_compositor); - if (!egl_display->wayland_surface) - { - error_message= "Failed to create a dummy wayland surface"; - goto fail; - } - - egl_display->wayland_egl_native_window = - wl_egl_window_create (egl_display->wayland_surface, - 1, - 1); - if (!egl_display->wayland_egl_native_window) - { - error_message= "Failed to create a dummy wayland native egl surface"; - goto fail; - } - - egl_display->dummy_surface = - eglCreateWindowSurface (edpy, - egl_display->egl_config, - (EGLNativeWindowType) - egl_display->wayland_egl_native_window, - NULL); - if (egl_display->dummy_surface == EGL_NO_SURFACE) - { - error_message= "Unable to eglMakeCurrent with dummy surface"; - goto fail; - } - - if (!eglMakeCurrent (edpy, - egl_display->dummy_surface, - egl_display->dummy_surface, - egl_display->egl_context)) - { - error_message = "Unable to eglMakeCurrent with dummy surface"; - goto fail; - } - break; -#endif - #ifdef COGL_HAS_EGL_PLATFORM_ANDROID_SUPPORT case COGL_WINSYS_ID_EGL_ANDROID: { @@ -671,28 +551,6 @@ cleanup_context (CoglDisplay *display) } break; #endif - -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - case COGL_WINSYS_ID_EGL_WAYLAND: - if (egl_display->dummy_surface != EGL_NO_SURFACE) - { - eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface); - egl_display->dummy_surface = EGL_NO_SURFACE; - } - - if (egl_display->wayland_egl_native_window) - { - wl_egl_window_destroy (egl_display->wayland_egl_native_window); - egl_display->wayland_egl_native_window = NULL; - } - - if (egl_display->wayland_surface) - { - wl_surface_destroy (egl_display->wayland_surface); - egl_display->wayland_surface = NULL; - } - break; -#endif } } @@ -845,10 +703,11 @@ _cogl_winsys_display_setup (CoglDisplay *display, #endif #ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT - if (renderer->winsys_vtable->id == COGL_WINSYS_ID_EGL_WAYLAND && - display->wayland_compositor_display) + if (display->wayland_compositor_display) { struct wl_display *wayland_display = display->wayland_compositor_display; + CoglRendererEGL *egl_renderer = display->renderer->winsys; + egl_renderer->pf_eglBindWaylandDisplay (egl_renderer->edpy, wayland_display); } @@ -889,16 +748,6 @@ _cogl_winsys_context_init (CoglContext *context, GError **error) if (!_cogl_context_update_features (context, error)) return FALSE; - if (renderer->winsys_vtable->id == COGL_WINSYS_ID_EGL_WAYLAND) - { - 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); - } - if (egl_renderer->private_features & COGL_EGL_WINSYS_FEATURE_SWAP_REGION) { COGL_FLAGS_SET (context->winsys_features, @@ -994,46 +843,6 @@ _cogl_winsys_onscreen_init (CoglOnscreen *onscreen, } break; -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - case COGL_WINSYS_ID_EGL_WAYLAND: - egl_onscreen->wayland_surface = - wl_compositor_create_surface (egl_renderer->wayland_compositor); - if (!egl_onscreen->wayland_surface) - { - g_set_error (error, COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_CREATE_ONSCREEN, - "Error while creating wayland surface for CoglOnscreen"); - return FALSE; - } - - egl_onscreen->wayland_shell_surface = - wl_shell_get_shell_surface (egl_renderer->wayland_shell, - egl_onscreen->wayland_surface); - - egl_onscreen->wayland_egl_native_window = - wl_egl_window_create (egl_onscreen->wayland_surface, - cogl_framebuffer_get_width (framebuffer), - cogl_framebuffer_get_height (framebuffer)); - if (!egl_onscreen->wayland_egl_native_window) - { - g_set_error (error, COGL_WINSYS_ERROR, - 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) - egl_onscreen->wayland_egl_native_window, - NULL); - - wl_shell_surface_set_toplevel (egl_onscreen->wayland_shell_surface); - break; -#endif - #if defined (COGL_HAS_EGL_PLATFORM_POWERVR_NULL_SUPPORT) || \ defined (COGL_HAS_EGL_PLATFORM_ANDROID_SUPPORT) || \ defined (COGL_HAS_EGL_PLATFORM_GDL_SUPPORT) @@ -1093,20 +902,6 @@ _cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen) egl_display->have_onscreen = FALSE; #endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - if (egl_onscreen->wayland_egl_native_window) - { - wl_egl_window_destroy (egl_onscreen->wayland_egl_native_window); - egl_onscreen->wayland_egl_native_window = NULL; - } - - if (egl_onscreen->wayland_surface) - { - wl_surface_destroy (egl_onscreen->wayland_surface); - egl_onscreen->wayland_surface = NULL; - } -#endif - g_slice_free (CoglOnscreenEGL, onscreen->winsys); onscreen->winsys = NULL; } @@ -1193,17 +988,6 @@ _cogl_winsys_onscreen_swap_buffers (CoglOnscreen *onscreen) COGL_FRAMEBUFFER_STATE_BIND); eglSwapBuffers (egl_renderer->edpy, egl_onscreen->egl_surface); - -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - /* - * The implementation of eglSwapBuffers may do a flush however the semantics - * of eglSwapBuffers on Wayland has changed in the past. So to be safe to - * the implementation changing we should explicitly ensure all messages are - * sent. - */ - if (renderer->winsys_vtable->id == COGL_WINSYS_ID_EGL_WAYLAND) - wl_display_flush (egl_renderer->wayland_display); -#endif } static void @@ -1267,126 +1051,6 @@ _cogl_winsys_egl_get_vtable (void) return &_cogl_winsys_vtable; } -/* FIXME: we should have a separate wayland file for these entry - * points... */ -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -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; -} - -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; - return egl_renderer->wayland_display; - } - else - return NULL; -} - -void -cogl_wayland_renderer_set_foreign_compositor (CoglRenderer *renderer, - struct wl_compositor *compositor) -{ - _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); - - /* NB: Renderers are considered immutable once connected */ - _COGL_RETURN_IF_FAIL (!renderer->connected); - - renderer->foreign_wayland_compositor = compositor; -} - -struct wl_compositor * -cogl_wayland_renderer_get_compositor (CoglRenderer *renderer) -{ - _COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL); - - if (renderer->foreign_wayland_compositor) - return renderer->foreign_wayland_compositor; - else if (renderer->connected) - { - CoglRendererEGL *egl_renderer = renderer->winsys; - return egl_renderer->wayland_compositor; - } - else - return NULL; -} - -void -cogl_wayland_renderer_set_foreign_shell (CoglRenderer *renderer, - struct wl_shell *shell) -{ - _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); - - /* NB: Renderers are considered immutable once connected */ - _COGL_RETURN_IF_FAIL (!renderer->connected); - - renderer->foreign_wayland_shell = shell; -} - -struct wl_shell * -cogl_wayland_renderer_get_shell (CoglRenderer *renderer) -{ - _COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL); - - if (renderer->foreign_wayland_shell) - return renderer->foreign_wayland_shell; - else if (renderer->connected) - { - CoglRendererEGL *egl_renderer = renderer->winsys; - return egl_renderer->wayland_shell; - } - else - return NULL; -} - -struct wl_surface * -cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen) -{ - CoglFramebuffer *fb; - - fb = COGL_FRAMEBUFFER (onscreen); - if (fb->allocated) - { - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - return egl_onscreen->wayland_surface; - } - else - return NULL; -} - - -struct wl_shell_surface * -cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen) -{ - CoglFramebuffer *fb; - - fb = COGL_FRAMEBUFFER (onscreen); - if (fb->allocated) - { - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - return egl_onscreen->wayland_shell_surface; - } - else - return NULL; -} - -#endif /* COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT */ - #ifdef EGL_KHR_image_base EGLImageKHR _cogl_egl_create_image (CoglContext *ctx,