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>
This commit is contained in:
Neil Roberts
parent
613a3390da
commit
4dbef01ec3
3 changed files with 489 additions and 360 deletions
|
|
@ -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 <wayland-client.h>
|
||||
#include <wayland-egl.h>
|
||||
#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 */
|
||||
|
|
|
|||
|
|
@ -29,8 +29,487 @@
|
|||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <wayland-client.h>
|
||||
#include <wayland-egl.h>
|
||||
#include <string.h>
|
||||
|
||||
#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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -43,11 +43,6 @@
|
|||
|
||||
#include "cogl-private.h"
|
||||
|
||||
#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT
|
||||
#include <wayland-client.h>
|
||||
#include <wayland-egl.h>
|
||||
#endif
|
||||
|
||||
#ifdef COGL_HAS_EGL_PLATFORM_ANDROID_SUPPORT
|
||||
#include <android/native_window.h>
|
||||
#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,
|
||||
|
|
|
|||
Loading…
Reference in a new issue