ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove support for Wayland 

Yes, this is a fancy new feature, but our Wayland support was
particularly bitrotten, and ideally this would be handled by a platform
layer like SDL. If not, we can always add this back in when GLInterface
has caught up. We might be able to even support wxWidgets and GL
together with subsurfaces!
This commit is contained in:
Jasper St. Pierre 2014-08-05 20:33:50 -04:00
parent 355f7b366b
commit 8bd4b9d2f9
11 changed files with 17 additions and 758 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
CMakeLists.txt
View File

@ -6,7 +6,6 @@ cmake_minimum_required(VERSION 2.8)
option(ANDROID "Enables a build for Android" OFF)
option(USE_EGL "Enables EGL OpenGL Interface" OFF)
option(TRY_X11 "Enables X11 Support" ON)
option(TRY_WAYLAND "Enables Wayland Support" OFF)
option(USE_UPNP "Enables UPnP port mapping support" ON)
option(DISABLE_WX "Disable wxWidgets (use CLI interface)" OFF)
option(ENABLE_PCH "Use PCH to speed up compilation" ON)
@ -324,7 +323,6 @@ if(ANDROID)
message("Building for Android")
add_definitions(-DANDROID)
set(USE_X11 0)
set(USE_WAYLAND 0)
set(USE_UPNP 0)
set(USE_EGL 1)
endif()
@ -407,26 +405,8 @@ if(NOT ANDROID)
endif(OPENAL_FOUND)
set(USE_X11 0)
set(USE_WAYLAND 0)
if(UNIX AND NOT APPLE)
# Note: The convention is to check TRY_X11 or TRY_WAYLAND where needed.
# This is where we detect platforms and set the variables accordingly.
pkg_check_modules(WAYLAND wayland-egl wayland-client wayland-cursor)
if(TRY_WAYLAND AND WAYLAND_FOUND)
pkg_check_modules(XKBCOMMON xkbcommon)
if(XKBCOMMON_FOUND)
set(USE_WAYLAND 1)
add_definitions(-DHAVE_WAYLAND)
include_directories(${WAYLAND_INCLUDE_DIR})
message("Wayland support enabled")
endif(XKBCOMMON_FOUND)
else()
set(USE_WAYLAND 0)
message("Wayland support disabled")
add_definitions(-DHAVE_WAYLAND=0)
endif(TRY_WAYLAND AND WAYLAND_FOUND)
# Note: We do not need to explicitly check for X11 as it is done in the cmake
# FindOpenGL module on linux.
if(TRY_X11 AND X11_FOUND)
@ -441,19 +421,13 @@ if(NOT ANDROID)
add_definitions(-DHAVE_X11=0)
endif(TRY_X11 AND X11_FOUND)
if (NOT USE_WAYLAND AND NOT USE_X11)
if (NOT USE_X11)
message(FATAL_ERROR "\n"
"No suitable display platform found\n"
"Requires wayland or x11 to run")
"Requires x11 to run")
endif()
endif()
# For now Wayland and EGL are tied to each other.
# The alternative would be an shm path
if(USE_WAYLAND)
set(USE_EGL 1)
endif()
if(USE_X11)
check_lib(XRANDR Xrandr)
if(XRANDR_FOUND)

6
Source/Core/DolphinWX/CMakeLists.txt
View File

@ -10,9 +10,6 @@ if(NOT ANDROID)
if(USE_X11)
set(LIBS ${LIBS} ${XRANDR_LIBRARIES})
endif()
if(USE_WAYLAND)
set(LIBS ${LIBS} ${WAYLAND_LIBRARIES} ${XKBCOMMON_LIBRARIES})
endif()
link_directories(${CMAKE_PREFIX_PATH}/lib)
else()
@ -78,9 +75,6 @@ set(ANDROID_SRCS Android/ButtonManager.cpp
if(USE_EGL)
set(SRCS ${SRCS} GLInterface/Platform.cpp
GLInterface/EGL.cpp)
if(USE_WAYLAND)
set(SRCS ${SRCS} GLInterface/Wayland_Util.cpp)
endif()
if(USE_X11)
set(SRCS ${SRCS} GLInterface/X11_Util.cpp)
endif()

5
Source/Core/DolphinWX/GLInterface/EGL.cpp
View File

@ -93,9 +93,6 @@ bool cInterfaceEGL::Create(void *&window_handle)
const char *s;
EGLint egl_major, egl_minor;
if (!Platform.SelectDisplay())
return false;
GLWin.egl_dpy = Platform.EGLGetDisplay();
if (!GLWin.egl_dpy)
@ -104,8 +101,6 @@ bool cInterfaceEGL::Create(void *&window_handle)
return false;
}
GLWin.platform = Platform.platform;
if (!eglInitialize(GLWin.egl_dpy, &egl_major, &egl_minor))
{
INFO_LOG(VIDEO, "Error: eglInitialize() failed\n");

6
Source/Core/DolphinWX/GLInterface/EGL.h
View File

@ -17,18 +17,12 @@ private:
#if HAVE_X11
cXInterface XInterface;
#endif
#if HAVE_WAYLAND
cWaylandInterface WaylandInterface;
#endif
public:
enum egl_platform platform;
bool SelectDisplay(void);
bool Init(EGLConfig config, void *window_handle);
EGLDisplay EGLGetDisplay(void);
EGLNativeWindowType CreateWindow(void);
void DestroyWindow(void);
void UpdateFPSDisplay(const std::string& text);
void ToggleFullscreen(bool fullscreen);
void SwapBuffers();
};

58
Source/Core/DolphinWX/GLInterface/GLInterface.h
View File

@ -7,23 +7,11 @@
#include "Common/Thread.h"
#if USE_EGL
// Currently Wayland/EGL and X11/EGL platforms are supported.
// The platform may be spelected at run time by setting the
// environment variable DOLPHIN_EGL_PLATFORM to "wayland" or "x11".
enum egl_platform {
EGL_PLATFORM_NONE,
EGL_PLATFORM_WAYLAND,
EGL_PLATFORM_X11,
EGL_PLATFORM_ANDROID
};
// Currently Android/EGL and X11/EGL platforms are supported.
#if HAVE_X11
#include "DolphinWX/GLInterface/X11_Util.h"
#endif
#if HAVE_WAYLAND
#include "DolphinWX/GLInterface/Wayland_Util.h"
#endif
#include "DolphinWX/GLInterface/EGL.h"
#elif defined(__APPLE__)
@ -37,55 +25,11 @@ enum egl_platform {
#error Platform doesnt have a GLInterface
#endif
#if HAVE_WAYLAND
struct geometry {
int width;
int height;
};
struct xkb {
struct xkb_context *context;
struct xkb_keymap *keymap;
struct xkb_state *state;
xkb_mod_mask_t control_mask;
xkb_mod_mask_t alt_mask;
xkb_mod_mask_t shift_mask;
};
#endif
typedef struct {
#if HAVE_WAYLAND
struct wl_display *wl_display;
struct wl_registry *wl_registry;
struct wl_compositor *wl_compositor;
struct wl_shell *wl_shell;
struct wl_seat *wl_seat;
struct {
struct wl_pointer *wl_pointer;
uint32_t serial;
} pointer;
struct {
struct wl_keyboard *wl_keyboard;
struct xkb xkb;
uint32_t modifiers;
} keyboard;
struct wl_shm *wl_shm;
struct wl_cursor_theme *wl_cursor_theme;
struct wl_cursor *wl_cursor;
struct wl_surface *wl_cursor_surface;
struct geometry geometry, window_size;
struct wl_egl_window *wl_egl_native;
struct wl_surface *wl_surface;
struct wl_shell_surface *wl_shell_surface;
bool fullscreen, running;
#endif
#if USE_EGL
EGLSurface egl_surf;
EGLContext egl_ctx;
EGLDisplay egl_dpy;
enum egl_platform platform;
EGLNativeWindowType native_window;
#elif HAVE_X11
GLXContext ctx;

177
Source/Core/DolphinWX/GLInterface/Platform.cpp
View File

@ -6,130 +6,12 @@
#include "Core/Host.h"
#include "DolphinWX/GLInterface/GLInterface.h"
bool cPlatform::SelectDisplay(void)
{
enum egl_platform selected_platform = EGL_PLATFORM_NONE;
enum egl_platform desired_platform = EGL_PLATFORM_NONE;
char *platform_env = getenv("DOLPHIN_EGL_PLATFORM");
if (platform_env)
platform_env = strdup(platform_env);
if (!platform_env)
printf("Running automatic platform detection\n");
// Try to select the platform set in the environment variable first
#if HAVE_WAYLAND
bool wayland_possible = WaylandInterface.ServerConnect();
if (platform_env && !strcmp(platform_env, "wayland"))
{
desired_platform = EGL_PLATFORM_WAYLAND;
if (wayland_possible)
selected_platform = EGL_PLATFORM_WAYLAND;
else
printf("Wayland display server connection failed\n");
}
#endif
#if HAVE_X11
bool x11_possible = XInterface.ServerConnect();
if (platform_env && !strcmp(platform_env, "x11"))
{
desired_platform = EGL_PLATFORM_X11;
if ((selected_platform != EGL_PLATFORM_WAYLAND) && x11_possible)
selected_platform = EGL_PLATFORM_X11;
else
printf("X11 display server connection failed\n");
}
#endif
// Fall back to automatic detection
if (selected_platform == EGL_PLATFORM_NONE)
{
if (platform_env && (desired_platform == EGL_PLATFORM_NONE)) {
printf("DOLPHIN_EGL_PLATFORM set to unrecognized platform \"%s\".\n"
#if HAVE_WAYLAND && !HAVE_X11
"Note: Valid value is \"wayland\" (built without x11 support)\n",
#endif
#if HAVE_X11 && !HAVE_WAYLAND
"Note: Valid values is \"x11\" (built without wayland support)\n",
#endif
#if HAVE_WAYLAND && HAVE_X11
"Note: Valid values are \"wayland\" and \"x11\"\n",
#endif
#if !HAVE_WAYLAND && !HAVE_X11
"Note: No Valid platform. Must be Android\n",
#endif
platform_env);
free(platform_env);
platform_env = nullptr;
}
#if HAVE_WAYLAND
if (wayland_possible)
{
selected_platform = EGL_PLATFORM_WAYLAND;
platform_env = strdup("wayland");
}
#endif
#if HAVE_X11
if ((selected_platform != EGL_PLATFORM_WAYLAND) && x11_possible)
{
selected_platform = EGL_PLATFORM_X11;
platform_env = strdup("x11");
}
#endif
#ifdef ANDROID
selected_platform = EGL_PLATFORM_ANDROID;
#endif
if (selected_platform == EGL_PLATFORM_NONE)
{
printf("FATAL: Failed to find suitable platform for display connection\n");
goto out;
}
}
printf("Using EGL Native Display Platform: %s\n", platform_env);
out:
cPlatform::platform = selected_platform;
free(platform_env);
#if HAVE_WAYLAND
if (selected_platform != EGL_PLATFORM_WAYLAND) {
if (GLWin.wl_display)
wl_display_disconnect(GLWin.wl_display);
}
#endif
#if HAVE_X11
if (selected_platform != EGL_PLATFORM_X11) {
if (GLWin.dpy)
{
XCloseDisplay(GLWin.dpy);
}
}
#endif
#if ANDROID
selected_platform = EGL_PLATFORM_ANDROID;
#endif
if (selected_platform == EGL_PLATFORM_NONE)
return false;
return true;
}
bool cPlatform::Init(EGLConfig config, void *window_handle)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
if (!WaylandInterface.Initialize(config))
return false;
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
if (!XInterface.Initialize(config, window_handle))
return false;
#endif
#ifdef ANDROID
if (!XInterface.Initialize(config, window_handle))
return false;
#elif ANDROID
EGLint format;
eglGetConfigAttrib(GLWin.egl_dpy, config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry((EGLNativeWindowType)Host_GetRenderHandle(), 0, 0, format);
@ -142,15 +24,9 @@ bool cPlatform::Init(EGLConfig config, void *window_handle)
EGLDisplay cPlatform::EGLGetDisplay(void)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
return (EGLDisplay) WaylandInterface.EGLGetDisplay();
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
return (EGLDisplay) XInterface.EGLGetDisplay();
#endif
#ifdef ANDROID
return (EGLDisplay) XInterface.EGLGetDisplay();
#elif ANDROID
return eglGetDisplay(EGL_DEFAULT_DISPLAY);
#endif
return nullptr;
@ -158,13 +34,8 @@ EGLDisplay cPlatform::EGLGetDisplay(void)
EGLNativeWindowType cPlatform::CreateWindow(void)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
return (EGLNativeWindowType) WaylandInterface.CreateWindow();
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
return (EGLNativeWindowType) XInterface.CreateWindow();
return (EGLNativeWindowType) XInterface.CreateWindow();
#endif
#ifdef ANDROID
return (EGLNativeWindowType)Host_GetRenderHandle();
@ -174,52 +45,24 @@ EGLNativeWindowType cPlatform::CreateWindow(void)
void cPlatform::DestroyWindow(void)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
WaylandInterface.DestroyWindow();
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
XInterface.DestroyWindow();
XInterface.DestroyWindow();
#endif
}
void cPlatform::UpdateFPSDisplay(const std::string& text)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
WaylandInterface.UpdateFPSDisplay(text);
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
XInterface.UpdateFPSDisplay(text);
#endif
}
void
cPlatform::ToggleFullscreen(bool fullscreen)
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
WaylandInterface.ToggleFullscreen(fullscreen);
#endif
#if HAVE_X11
// Only wayland uses this function
XInterface.UpdateFPSDisplay(text);
#endif
}
void
cPlatform::SwapBuffers()
{
#if HAVE_WAYLAND
if (cPlatform::platform == EGL_PLATFORM_WAYLAND)
WaylandInterface.SwapBuffers();
#endif
#if HAVE_X11
if (cPlatform::platform == EGL_PLATFORM_X11)
XInterface.SwapBuffers();
#endif
#if ANDROID
XInterface.SwapBuffers();
#elif ANDROID
eglSwapBuffers(GLWin.egl_dpy, GLWin.egl_surf);
#endif
}

404
Source/Core/DolphinWX/GLInterface/Wayland_Util.cpp
View File

@ -1,404 +0,0 @@
// Copyright (C) 2013 Scott Moreau <oreaus@gmail.com>
// Licensed under GPLv2
// Refer to the license.txt file included.
#include <linux/input.h>
#include <sys/mman.h>
#include "Core/Core.h"
#include "Core/State.h"
#include "DolphinWX/GLInterface/GLInterface.h"
static void
hide_cursor(void)
{
if (!GLWin.pointer.wl_pointer)
return;
wl_pointer_set_cursor(GLWin.pointer.wl_pointer,
GLWin.pointer.serial, nullptr, 0, 0);
}
static void
handle_ping(void *data, struct wl_shell_surface *wl_shell_surface,
uint32_t serial)
{
wl_shell_surface_pong(wl_shell_surface, serial);
}
static void
handle_configure(void *data, struct wl_shell_surface *wl_shell_surface,
uint32_t edges, int32_t width, int32_t height)
{
if (GLWin.wl_egl_native)
wl_egl_window_resize(GLWin.wl_egl_native, width, height, 0, 0);
GLWin.geometry.width = width;
GLWin.geometry.height = height;
GLInterface->SetBackBufferDimensions(width, height);
if (!GLWin.fullscreen)
GLWin.window_size = GLWin.geometry;
}
static void
handle_popup_done(void *data, struct wl_shell_surface *wl_shell_surface)
{
}
static const struct wl_shell_surface_listener shell_surface_listener = {
handle_ping,
handle_configure,
handle_popup_done
};
static void
pointer_handle_enter(void *data, struct wl_pointer *pointer,
uint32_t serial, struct wl_surface *surface,
wl_fixed_t sx, wl_fixed_t sy)
{
GLWin.pointer.serial = serial;
hide_cursor();
}
static void
pointer_handle_leave(void *data, struct wl_pointer *pointer,
uint32_t serial, struct wl_surface *surface)
{
}
static void
pointer_handle_motion(void *data, struct wl_pointer *pointer,
uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
{
}
static void
pointer_handle_button(void *data, struct wl_pointer *wl_pointer,
uint32_t serial, uint32_t time, uint32_t button,
uint32_t state)
{
}
static void
pointer_handle_axis(void *data, struct wl_pointer *wl_pointer,
uint32_t time, uint32_t axis, wl_fixed_t value)
{
}
static const struct wl_pointer_listener pointer_listener = {
pointer_handle_enter,
pointer_handle_leave,
pointer_handle_motion,
pointer_handle_button,
pointer_handle_axis,
};
static void
toggle_fullscreen(bool fullscreen)
{
GLWin.fullscreen = fullscreen;
if (fullscreen) {
wl_shell_surface_set_fullscreen(GLWin.wl_shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0, nullptr);
} else {
wl_shell_surface_set_toplevel(GLWin.wl_shell_surface);
handle_configure(nullptr, GLWin.wl_shell_surface, 0,
GLWin.window_size.width,
GLWin.window_size.height);
}
}
static void
keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
uint32_t format, int fd, uint32_t size)
{
char *map_str;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
return;
}
map_str = (char *) mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED) {
close(fd);
return;
}
GLWin.keyboard.xkb.keymap = xkb_map_new_from_string(GLWin.keyboard.xkb.context,
map_str,
XKB_KEYMAP_FORMAT_TEXT_V1,
(xkb_keymap_compile_flags) 0);
munmap(map_str, size);
close(fd);
if (!GLWin.keyboard.xkb.keymap) {
fprintf(stderr, "failed to compile keymap\n");
return;
}
GLWin.keyboard.xkb.state = xkb_state_new(GLWin.keyboard.xkb.keymap);
if (!GLWin.keyboard.xkb.state) {
fprintf(stderr, "failed to create XKB state\n");
xkb_map_unref(GLWin.keyboard.xkb.keymap);
GLWin.keyboard.xkb.keymap = nullptr;
return;
}
GLWin.keyboard.xkb.control_mask =
1 << xkb_map_mod_get_index(GLWin.keyboard.xkb.keymap, "Control");
GLWin.keyboard.xkb.alt_mask =
1 << xkb_map_mod_get_index(GLWin.keyboard.xkb.keymap, "Mod1");
GLWin.keyboard.xkb.shift_mask =
1 << xkb_map_mod_get_index(GLWin.keyboard.xkb.keymap, "Shift");
}
static void
keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
uint32_t serial, struct wl_surface *surface,
struct wl_array *keys)
{
}
static void
keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
uint32_t serial, struct wl_surface *surface)
{
}
static void
keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t time, uint32_t key,
uint32_t state)
{
if (state == WL_KEYBOARD_KEY_STATE_RELEASED)
return;
if (key == KEY_ESC) {
Core::Stop();
GLWin.running = 0;
} else if ((key == KEY_P) ||
((key == KEY_ENTER) && (GLWin.keyboard.modifiers == 0)))
Core::SetState((Core::GetState() == Core::CORE_RUN) ?
Core::CORE_PAUSE : Core::CORE_RUN);
else if (key == KEY_F)
toggle_fullscreen(!GLWin.fullscreen);
else if ((key == KEY_ENTER) && (GLWin.keyboard.modifiers == MOD_ALT_MASK))
toggle_fullscreen(!GLWin.fullscreen);
else if (key >= KEY_F1 && key <= KEY_F8) {
int slot_number = key - KEY_F1 + 1;
if (GLWin.keyboard.modifiers == MOD_SHIFT_MASK)
State::Save(slot_number);
else
State::Load(slot_number);
}
else if (key == KEY_F9)
Core::SaveScreenShot();
else if (key == KEY_F11)
State::LoadLastSaved();
else if (key == KEY_F12) {
if (GLWin.keyboard.modifiers == MOD_SHIFT_MASK)
State::UndoLoadState();
else
State::UndoSaveState();
}
}
static void
keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t mods_depressed,
uint32_t mods_latched, uint32_t mods_locked,
uint32_t group)
{
xkb_mod_mask_t mask;
xkb_state_update_mask(GLWin.keyboard.xkb.state, mods_depressed, mods_latched,
mods_locked, 0, 0, group);
mask = xkb_state_serialize_mods(GLWin.keyboard.xkb.state,
(xkb_state_component)
(XKB_STATE_DEPRESSED |
XKB_STATE_LATCHED));
GLWin.keyboard.modifiers = 0;
if (mask & GLWin.keyboard.xkb.control_mask)
GLWin.keyboard.modifiers |= MOD_CONTROL_MASK;
if (mask & GLWin.keyboard.xkb.alt_mask)
GLWin.keyboard.modifiers |= MOD_ALT_MASK;
if (mask & GLWin.keyboard.xkb.shift_mask)
GLWin.keyboard.modifiers |= MOD_SHIFT_MASK;
}
static const struct wl_keyboard_listener keyboard_listener = {
keyboard_handle_keymap,
keyboard_handle_enter,
keyboard_handle_leave,
keyboard_handle_key,
keyboard_handle_modifiers,
};
static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
uint32_t caps)
{
struct wl_pointer *wl_pointer = nullptr;
struct wl_keyboard *wl_keyboard = nullptr;
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !wl_pointer) {
wl_pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(wl_pointer, &pointer_listener, 0);
} else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && wl_pointer) {
wl_pointer_destroy(wl_pointer);
wl_pointer = nullptr;
}
GLWin.pointer.wl_pointer = wl_pointer;
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !wl_keyboard) {
wl_keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, 0);
} else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && wl_keyboard) {
wl_keyboard_destroy(wl_keyboard);
wl_keyboard = nullptr;
}
GLWin.keyboard.wl_keyboard = wl_keyboard;
}
static const struct wl_seat_listener seat_listener = {
seat_handle_capabilities,
};
static void
registry_handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0) {
GLWin.wl_compositor = (wl_compositor *)
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_shell") == 0) {
GLWin.wl_shell = (wl_shell *) wl_registry_bind(registry, name,
&wl_shell_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
GLWin.wl_seat = (wl_seat *) wl_registry_bind(registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(GLWin.wl_seat, &seat_listener, 0);
} else if (strcmp(interface, "wl_shm") == 0) {
GLWin.wl_shm = (wl_shm *) wl_registry_bind(registry, name,
&wl_shm_interface, 1);
GLWin.wl_cursor_theme = (wl_cursor_theme *) wl_cursor_theme_load(nullptr, 32, GLWin.wl_shm);
GLWin.wl_cursor = (wl_cursor *)
wl_cursor_theme_get_cursor(GLWin.wl_cursor_theme, "left_ptr");
}
}
static void
registry_handle_global_remove(void *data, struct wl_registry *registry,
uint32_t name)
{
}
static const struct wl_registry_listener registry_listener = {
registry_handle_global,
registry_handle_global_remove
};
bool cWaylandInterface::ServerConnect(void)
{
GLWin.wl_display = wl_display_connect(nullptr);
if (!GLWin.wl_display)
return false;
return true;
}
bool cWaylandInterface::Initialize(void *config)
{
if (!GLWin.wl_display) {
printf("Error: couldn't open wayland display\n");
return false;
}
GLWin.pointer.wl_pointer = nullptr;
GLWin.keyboard.wl_keyboard = nullptr;
GLWin.keyboard.xkb.context = xkb_context_new((xkb_context_flags) 0);
if (GLWin.keyboard.xkb.context == nullptr) {
fprintf(stderr, "Failed to create XKB context\n");
return nullptr;
}
GLWin.wl_registry = wl_display_get_registry(GLWin.wl_display);
wl_registry_add_listener(GLWin.wl_registry,
&registry_listener, nullptr);
while (!GLWin.wl_compositor)
wl_display_dispatch(GLWin.wl_display);
GLWin.wl_cursor_surface =
wl_compositor_create_surface(GLWin.wl_compositor);
return true;
}
void *cWaylandInterface::EGLGetDisplay(void)
{
return eglGetDisplay(GLWin.wl_display);
}
void *cWaylandInterface::CreateWindow(void)
{
GLWin.window_size.width = 640;
GLWin.window_size.height = 480;
GLWin.fullscreen = true;
GLWin.wl_surface = wl_compositor_create_surface(GLWin.wl_compositor);
GLWin.wl_shell_surface = wl_shell_get_shell_surface(GLWin.wl_shell,
GLWin.wl_surface);
wl_shell_surface_add_listener(GLWin.wl_shell_surface,
&shell_surface_listener, 0);
GLWin.wl_egl_native = wl_egl_window_create(GLWin.wl_surface,
GLWin.window_size.width,
GLWin.window_size.height);
return GLWin.wl_egl_native;
}
void cWaylandInterface::DestroyWindow(void)
{
wl_egl_window_destroy(GLWin.wl_egl_native);
wl_shell_surface_destroy(GLWin.wl_shell_surface);
wl_surface_destroy(GLWin.wl_surface);
}
void cWaylandInterface::UpdateFPSDisplay(const std::string& text)
{
wl_shell_surface_set_title(GLWin.wl_shell_surface, text.c_str());
}
void cWaylandInterface::ToggleFullscreen(bool fullscreen)
{
toggle_fullscreen(fullscreen);
}
void cWaylandInterface::SwapBuffers()
{
struct wl_region *region;
region = wl_compositor_create_region(GLWin.wl_compositor);
wl_region_add(region, 0, 0,
GLWin.geometry.width,
GLWin.geometry.height);
wl_surface_set_opaque_region(GLWin.wl_surface, region);
wl_region_destroy(region);
eglSwapBuffers(GLWin.egl_dpy, GLWin.egl_surf);
}

29
Source/Core/DolphinWX/GLInterface/Wayland_Util.h
View File

@ -1,29 +0,0 @@
// Copyright (C) 2013 Scott Moreau <oreaus@gmail.com>
// Licensed under GPLv2
// Refer to the license.txt file included.
#pragma once
#include <string>
#include <wayland-client.h>
#include <wayland-cursor.h>
#include <wayland-egl.h>
#include <xkbcommon/xkbcommon.h>
#define MOD_SHIFT_MASK 0x01
#define MOD_ALT_MASK 0x02
#define MOD_CONTROL_MASK 0x04
class cWaylandInterface
{
public:
bool ServerConnect(void);
bool Initialize(void *config);
void *EGLGetDisplay(void);
void *CreateWindow(void);
void DestroyWindow(void);
void UpdateFPSDisplay(const std::string& text);
void ToggleFullscreen(bool fullscreen);
void SwapBuffers();
};

4
Source/Core/DolphinWX/GLInterface/X11_Util.cpp
View File

@ -53,11 +53,7 @@ bool cXInterface::Initialize(void *config, void *window_handle)
void *cXInterface::EGLGetDisplay(void)
{
#if HAVE_WAYLAND
return eglGetDisplay((wl_display *) GLWin.dpy);
#else
return eglGetDisplay(GLWin.dpy);
#endif
}
void *cXInterface::CreateWindow(void)

47
Source/Core/DolphinWX/MainNoGUI.cpp
View File

@ -29,10 +29,6 @@
#include "DolphinWX/X11Utils.h"
#endif
#if HAVE_WAYLAND
#include <wayland-client.h>
#endif
#ifdef USE_EGL
#include "DolphinWX/GLInterface/GLInterface.h"
#endif
@ -262,23 +258,6 @@ static void X11_MainLoop()
}
#endif
#if HAVE_WAYLAND
static void Wayland_MainLoop()
{
// Wait for display to be initialized
while (!GLWin.wl_display)
usleep(20000);
GLWin.running = 1;
while (GLWin.running)
wl_display_dispatch(GLWin.wl_display);
if (GLWin.wl_display)
wl_display_disconnect(GLWin.wl_display);
}
#endif
int main(int argc, char* argv[])
{
#ifdef __APPLE__
@ -330,34 +309,12 @@ int main(int argc, char* argv[])
m_LocalCoreStartupParameter.m_strVideoBackend);
WiimoteReal::LoadSettings();
#if USE_EGL
GLWin.platform = EGL_PLATFORM_NONE;
#endif
#if HAVE_WAYLAND
GLWin.wl_display = nullptr;
#endif
// No use running the loop when booting fails
if (BootManager::BootCore(argv[optind]))
{
#if USE_EGL
while (GLWin.platform == EGL_PLATFORM_NONE)
usleep(20000);
#endif
#if HAVE_WAYLAND
if (GLWin.platform == EGL_PLATFORM_WAYLAND)
Wayland_MainLoop();
#endif
#if HAVE_X11
#if USE_EGL
if (GLWin.platform == EGL_PLATFORM_X11)
{
#endif
XInitThreads();
X11_MainLoop();
#if USE_EGL
}
#endif
XInitThreads();
X11_MainLoop();
#endif
#ifdef __APPLE__
while (running)

9
Source/Core/InputCommon/ControllerInterface/ControllerInterface.cpp
View File

@ -57,15 +57,10 @@ void ControllerInterface::Initialize()
ciface::XInput::Init(m_devices);
#endif
#ifdef CIFACE_USE_XLIB
#if USE_EGL
if (GLWin.platform == EGL_PLATFORM_X11)
#endif
{
ciface::Xlib::Init(m_devices, m_hwnd);
ciface::Xlib::Init(m_devices, m_hwnd);
#ifdef CIFACE_USE_X11_XINPUT2
ciface::XInput2::Init(m_devices, m_hwnd);
ciface::XInput2::Init(m_devices, m_hwnd);
#endif
}
#endif
#ifdef CIFACE_USE_OSX
ciface::OSX::Init(m_devices, m_hwnd);