diff options
Diffstat (limited to 'source/3rd-party/SDL2/src/video/mir')
17 files changed, 2532 insertions, 0 deletions
diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.c new file mode 100644 index 0000000..71dc73c --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.c @@ -0,0 +1,170 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#define DEBUG_DYNAMIC_MIR 0 + +#include "SDL_mirdyn.h" + +#if DEBUG_DYNAMIC_MIR +#include "SDL_log.h" +#endif + +#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC + +#include "SDL_name.h" +#include "SDL_loadso.h" + +typedef struct +{ + void *lib; + const char *libname; +} mirdynlib; + +#ifndef SDL_VIDEO_DRIVER_MIR_DYNAMIC +#define SDL_VIDEO_DRIVER_MIR_DYNAMIC NULL +#endif +#ifndef SDL_VIDEO_DRIVER_MIR_DYNAMIC_XKBCOMMON +#define SDL_VIDEO_DRIVER_MIR_DYNAMIC_XKBCOMMON NULL +#endif + +static mirdynlib mirlibs[] = { + {NULL, SDL_VIDEO_DRIVER_MIR_DYNAMIC}, + {NULL, SDL_VIDEO_DRIVER_MIR_DYNAMIC_XKBCOMMON} +}; + +static void * +MIR_GetSym(const char *fnname, int *pHasModule) +{ + int i; + void *fn = NULL; + for (i = 0; i < SDL_TABLESIZE(mirlibs); i++) { + if (mirlibs[i].lib != NULL) { + fn = SDL_LoadFunction(mirlibs[i].lib, fnname); + if (fn != NULL) + break; + } + } + +#if DEBUG_DYNAMIC_MIR + if (fn != NULL) + SDL_Log("MIR: Found '%s' in %s (%p)\n", fnname, mirlibs[i].libname, fn); + else + SDL_Log("MIR: Symbol '%s' NOT FOUND!\n", fnname); +#endif + + if (fn == NULL) + *pHasModule = 0; /* kill this module. */ + + return fn; +} + +#endif /* SDL_VIDEO_DRIVER_MIR_DYNAMIC */ + +/* Define all the function pointers and wrappers... */ +#define SDL_MIR_MODULE(modname) int SDL_MIR_HAVE_##modname = 0; +#define SDL_MIR_SYM(rc,fn,params) SDL_DYNMIRFN_##fn MIR_##fn = NULL; +#define SDL_MIR_SYM_CONST(type,name) SDL_DYMMIRCONST_##name MIR_##name = NULL; +#include "SDL_mirsym.h" + +static int mir_load_refcount = 0; + +void +SDL_MIR_UnloadSymbols(void) +{ + /* Don't actually unload if more than one module is using the libs... */ + if (mir_load_refcount > 0) { + if (--mir_load_refcount == 0) { +#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC + int i; +#endif + + /* set all the function pointers to NULL. */ +#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 0; +#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = NULL; +#define SDL_MIR_SYM_CONST(type,name) MIR_##name = NULL; +#include "SDL_mirsym.h" + + +#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC + for (i = 0; i < SDL_TABLESIZE(mirlibs); i++) { + if (mirlibs[i].lib != NULL) { + SDL_UnloadObject(mirlibs[i].lib); + mirlibs[i].lib = NULL; + } + } +#endif + } + } +} + +/* returns non-zero if all needed symbols were loaded. */ +int +SDL_MIR_LoadSymbols(void) +{ + int rc = 1; /* always succeed if not using Dynamic MIR stuff. */ + + /* deal with multiple modules (dga, wayland, mir, etc) needing these symbols... */ + if (mir_load_refcount++ == 0) { +#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC + int i; + int *thismod = NULL; + for (i = 0; i < SDL_TABLESIZE(mirlibs); i++) { + if (mirlibs[i].libname != NULL) { + mirlibs[i].lib = SDL_LoadObject(mirlibs[i].libname); + } + } + +#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 1; /* default yes */ +#include "SDL_mirsym.h" + +#define SDL_MIR_MODULE(modname) thismod = &SDL_MIR_HAVE_##modname; +#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = (SDL_DYNMIRFN_##fn) MIR_GetSym(#fn,thismod); +#define SDL_MIR_SYM_CONST(type,name) MIR_##name = *(SDL_DYMMIRCONST_##name*) MIR_GetSym(#name,thismod); +#include "SDL_mirsym.h" + + if ((SDL_MIR_HAVE_MIR_CLIENT) && (SDL_MIR_HAVE_XKBCOMMON)) { + /* all required symbols loaded. */ + SDL_ClearError(); + } else { + /* in case something got loaded... */ + SDL_MIR_UnloadSymbols(); + rc = 0; + } + +#else /* no dynamic MIR */ + +#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 1; /* default yes */ +#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = fn; +#define SDL_MIR_SYM_CONST(type,name) MIR_##name = name; +#include "SDL_mirsym.h" + +#endif + } + + return rc; +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.h new file mode 100644 index 0000000..32364aa --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirdyn.h @@ -0,0 +1,53 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +#ifndef SDL_mirdyn_h_ +#define SDL_mirdyn_h_ + +#include "../../SDL_internal.h" + +#include <EGL/egl.h> +#include <mir_toolkit/mir_client_library.h> +#include <xkbcommon/xkbcommon.h> + +#ifdef __cplusplus +extern "C" { +#endif + +int SDL_MIR_LoadSymbols(void); +void SDL_MIR_UnloadSymbols(void); + +/* Declare all the function pointers and wrappers... */ +#define SDL_MIR_SYM(rc,fn,params) \ + typedef rc (*SDL_DYNMIRFN_##fn) params; \ + extern SDL_DYNMIRFN_##fn MIR_##fn; +#define SDL_MIR_SYM_CONST(type, name) \ + typedef type SDL_DYMMIRCONST_##name; \ + extern SDL_DYMMIRCONST_##name MIR_##name; +#include "SDL_mirsym.h" + +#ifdef __cplusplus +} +#endif + +#endif /* !defined SDL_mirdyn_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.c new file mode 100644 index 0000000..df92799 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.c @@ -0,0 +1,321 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "../../events/SDL_events_c.h" +#include "../../events/SDL_keyboard_c.h" +#include "../../events/SDL_touch_c.h" +#include "../../events/scancodes_xfree86.h" + +#include "SDL_mirevents.h" +#include "SDL_mirwindow.h" + +#include <xkbcommon/xkbcommon.h> + +#include "SDL_mirdyn.h" + +static void +HandleKeyText(int32_t key_code) +{ + char text[8]; + int size = 0; + + size = MIR_xkb_keysym_to_utf8(key_code, text, sizeof text); + + if (size > 0) { + text[size] = '\0'; + SDL_SendKeyboardText(text); + } +} + +/* FIXME + Mir still needs to implement its IM API, for now we assume + a single key press produces a character. +*/ +static void +HandleKeyEvent(MirKeyboardEvent const* key_event, SDL_Window* window) +{ + xkb_keysym_t key_code; + Uint8 key_state; + int event_scancode; + uint32_t sdl_scancode = SDL_SCANCODE_UNKNOWN; + + MirKeyboardAction action = MIR_mir_keyboard_event_action(key_event); + + key_state = SDL_PRESSED; + key_code = MIR_mir_keyboard_event_key_code(key_event); + event_scancode = MIR_mir_keyboard_event_scan_code(key_event); + + if (action == mir_keyboard_action_up) + key_state = SDL_RELEASED; + + if (event_scancode < SDL_arraysize(xfree86_scancode_table2)) + sdl_scancode = xfree86_scancode_table2[event_scancode]; + + if (sdl_scancode != SDL_SCANCODE_UNKNOWN) + SDL_SendKeyboardKey(key_state, sdl_scancode); + + if (key_state == SDL_PRESSED) + HandleKeyText(key_code); +} + +static void +HandleMouseButton(SDL_Window* sdl_window, Uint8 state, MirPointerEvent const* pointer) +{ + uint32_t sdl_button = SDL_BUTTON_LEFT; + MirPointerButton button_state = mir_pointer_button_primary; + + static uint32_t old_button_states = 0; + uint32_t new_button_states = MIR_mir_pointer_event_buttons(pointer); + + // XOR on our old button states vs our new states to get the newley pressed/released button + button_state = new_button_states ^ old_button_states; + + switch (button_state) { + case mir_pointer_button_primary: + sdl_button = SDL_BUTTON_LEFT; + break; + case mir_pointer_button_secondary: + sdl_button = SDL_BUTTON_RIGHT; + break; + case mir_pointer_button_tertiary: + sdl_button = SDL_BUTTON_MIDDLE; + break; + case mir_pointer_button_forward: + sdl_button = SDL_BUTTON_X1; + break; + case mir_pointer_button_back: + sdl_button = SDL_BUTTON_X2; + break; + default: + break; + } + + old_button_states = new_button_states; + + SDL_SendMouseButton(sdl_window, 0, state, sdl_button); +} + +static void +HandleMouseMotion(SDL_Window* sdl_window, int x, int y) +{ + SDL_Mouse* mouse = SDL_GetMouse(); + SDL_SendMouseMotion(sdl_window, 0, mouse->relative_mode, x, y); +} + +static void +HandleTouchPress(int device_id, int source_id, SDL_bool down, float x, float y, float pressure) +{ + SDL_SendTouch(device_id, source_id, down, x, y, pressure); +} + +static void +HandleTouchMotion(int device_id, int source_id, float x, float y, float pressure) +{ + SDL_SendTouchMotion(device_id, source_id, x, y, pressure); +} + +static void +HandleMouseScroll(SDL_Window* sdl_window, float hscroll, float vscroll) +{ + SDL_SendMouseWheel(sdl_window, 0, hscroll, vscroll, SDL_MOUSEWHEEL_NORMAL); +} + +static void +AddTouchDevice(int device_id) +{ + if (SDL_AddTouch(device_id, "") < 0) + SDL_SetError("Error: can't add touch %s, %d", __FILE__, __LINE__); +} + +static void +HandleTouchEvent(MirTouchEvent const* touch, int device_id, SDL_Window* sdl_window) +{ + int i, point_count; + point_count = MIR_mir_touch_event_point_count(touch); + + AddTouchDevice(device_id); + + for (i = 0; i < point_count; i++) { + int id = MIR_mir_touch_event_id(touch, i); + + int width = sdl_window->w; + int height = sdl_window->h; + + float x = MIR_mir_touch_event_axis_value(touch, i, mir_touch_axis_x); + float y = MIR_mir_touch_event_axis_value(touch, i, mir_touch_axis_y); + + float n_x = x / width; + float n_y = y / height; + + float pressure = MIR_mir_touch_event_axis_value(touch, i, mir_touch_axis_pressure); + + switch (MIR_mir_touch_event_action(touch, i)) { + case mir_touch_action_up: + HandleTouchPress(device_id, id, SDL_FALSE, n_x, n_y, pressure); + break; + case mir_touch_action_down: + HandleTouchPress(device_id, id, SDL_TRUE, n_x, n_y, pressure); + break; + case mir_touch_action_change: + HandleTouchMotion(device_id, id, n_x, n_y, pressure); + break; + case mir_touch_actions: + break; + } + } +} + +static void +HandleMouseEvent(MirPointerEvent const* pointer, SDL_Window* sdl_window) +{ + SDL_SetMouseFocus(sdl_window); + + switch (MIR_mir_pointer_event_action(pointer)) { + case mir_pointer_action_button_down: + HandleMouseButton(sdl_window, SDL_PRESSED, pointer); + break; + case mir_pointer_action_button_up: + HandleMouseButton(sdl_window, SDL_RELEASED, pointer); + break; + case mir_pointer_action_motion: { + int x, y; + float hscroll, vscroll; + SDL_Mouse* mouse = SDL_GetMouse(); + x = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_x); + y = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_y); + + if (mouse) { + if (mouse->relative_mode) { + int relative_x = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_relative_x); + int relative_y = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_relative_y); + HandleMouseMotion(sdl_window, relative_x, relative_y); + } + else if (mouse->x != x || mouse->y != y) { + HandleMouseMotion(sdl_window, x, y); + } + } + + hscroll = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_hscroll); + vscroll = MIR_mir_pointer_event_axis_value(pointer, mir_pointer_axis_vscroll); + if (vscroll != 0 || hscroll != 0) + HandleMouseScroll(sdl_window, hscroll, vscroll); + } + break; + case mir_pointer_action_leave: + SDL_SetMouseFocus(NULL); + break; + case mir_pointer_action_enter: + default: + break; + } +} + +static void +HandleInput(MirInputEvent const* input_event, SDL_Window* window) +{ + switch (MIR_mir_input_event_get_type(input_event)) { + case (mir_input_event_type_key): + HandleKeyEvent(MIR_mir_input_event_get_keyboard_event(input_event), window); + break; + case (mir_input_event_type_pointer): + HandleMouseEvent(MIR_mir_input_event_get_pointer_event(input_event), window); + break; + case (mir_input_event_type_touch): + HandleTouchEvent(MIR_mir_input_event_get_touch_event(input_event), + MIR_mir_input_event_get_device_id(input_event), + window); + break; + default: + break; + } +} + +static void +HandleResize(MirResizeEvent const* resize_event, SDL_Window* window) +{ + int new_w = MIR_mir_resize_event_get_width (resize_event); + int new_h = MIR_mir_resize_event_get_height(resize_event); + + int old_w = window->w; + int old_h = window->h; + + if (new_w != old_w || new_h != old_h) + SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, new_w, new_h); +} + +static void +HandleWindow(MirWindowEvent const* event, SDL_Window* window) +{ + MirWindowAttrib attrib = MIR_mir_window_event_get_attribute(event); + int value = MIR_mir_window_event_get_attribute_value(event); + + if (attrib == mir_window_attrib_focus) { + if (value == mir_window_focus_state_focused) { + SDL_SetKeyboardFocus(window); + } + else if (value == mir_window_focus_state_unfocused) { + SDL_SetKeyboardFocus(NULL); + } + } +} + +static void +MIR_HandleClose(SDL_Window* window) { + SDL_SendWindowEvent(window, SDL_WINDOWEVENT_CLOSE, 0, 0); +} + +void +MIR_HandleEvent(MirWindow* mirwindow, MirEvent const* ev, void* context) +{ + MirEventType event_type = MIR_mir_event_get_type(ev); + SDL_Window* window = (SDL_Window*)context; + + if (window) { + switch (event_type) { + case (mir_event_type_input): + HandleInput(MIR_mir_event_get_input_event(ev), window); + break; + case (mir_event_type_resize): + HandleResize(MIR_mir_event_get_resize_event(ev), window); + break; + case (mir_event_type_window): + HandleWindow(MIR_mir_event_get_window_event(ev), window); + break; + case (mir_event_type_close_window): + MIR_HandleClose(window); + break; + default: + break; + } + } +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.h new file mode 100644 index 0000000..4b0f209 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirevents.h @@ -0,0 +1,37 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_mirevents_h_ +#define SDL_mirevents_h_ + +#include <mir_toolkit/mir_client_library.h> + +extern void +MIR_HandleEvent(MirWindow*, MirEvent const* ev, void* context); + +#endif /* SDL_mirevents_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ + diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.c new file mode 100644 index 0000000..d678fff --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.c @@ -0,0 +1,134 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "SDL_mirevents.h" +#include "SDL_mirframebuffer.h" +#include "SDL_mirwindow.h" + +#include "SDL_mirdyn.h" + +int +MIR_CreateWindowFramebuffer(_THIS, SDL_Window* window, Uint32* format, + void** pixels, int* pitch) +{ + MIR_Data* mir_data = _this->driverdata; + + mir_data->software = SDL_TRUE; + + if (MIR_CreateWindow(_this, window) < 0) + return SDL_SetError("Failed to create a mir window."); + + *format = MIR_GetSDLPixelFormat(mir_data->pixel_format); + if (*format == SDL_PIXELFORMAT_UNKNOWN) + return SDL_SetError("Unknown pixel format"); + + *pitch = (((window->w * SDL_BYTESPERPIXEL(*format)) + 3) & ~3); + + *pixels = SDL_malloc(window->h*(*pitch)); + if (*pixels == NULL) + return SDL_OutOfMemory(); + + return 0; +} + +int +MIR_UpdateWindowFramebuffer(_THIS, SDL_Window* window, + const SDL_Rect* rects, int numrects) +{ + MIR_Window* mir_window = window->driverdata; + + MirGraphicsRegion region; + MirBufferStream* bs; + int i, j, x, y, w, h, start; + int bytes_per_pixel, bytes_per_row, s_stride, d_stride; + char* s_dest; + char* pixels; + + bs = MIR_mir_window_get_buffer_stream(mir_window->window); + MIR_mir_buffer_stream_get_graphics_region(bs, ®ion); + + s_dest = region.vaddr; + pixels = (char*)window->surface->pixels; + + s_stride = window->surface->pitch; + d_stride = region.stride; + bytes_per_pixel = window->surface->format->BytesPerPixel; + + for (i = 0; i < numrects; i++) { + s_dest = region.vaddr; + pixels = (char*)window->surface->pixels; + + x = rects[i].x; + y = rects[i].y; + w = rects[i].w; + h = rects[i].h; + + if (w <= 0 || h <= 0 || (x + w) <= 0 || (y + h) <= 0) + continue; + + if (x < 0) { + x += w; + w += rects[i].x; + } + + if (y < 0) { + y += h; + h += rects[i].y; + } + + if (x + w > window->w) + w = window->w - x; + if (y + h > window->h) + h = window->h - y; + + start = y * s_stride + x; + pixels += start; + s_dest += start; + + bytes_per_row = bytes_per_pixel * w; + for (j = 0; j < h; j++) { + SDL_memcpy(s_dest, pixels, bytes_per_row); + pixels += s_stride; + s_dest += d_stride; + } + } + + MIR_mir_buffer_stream_swap_buffers_sync(bs); + + return 0; +} + +void +MIR_DestroyWindowFramebuffer(_THIS, SDL_Window* window) +{ +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.h new file mode 100644 index 0000000..502337c --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirframebuffer.h @@ -0,0 +1,47 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_mirframebuffer_h_ +#define SDL_mirframebuffer_h_ + +#include "../SDL_sysvideo.h" + +#include "SDL_mirvideo.h" + +extern int +MIR_CreateWindowFramebuffer(_THIS, SDL_Window* sdl_window, Uint32* format, + void** pixels, int* pitch); + +extern int +MIR_UpdateWindowFramebuffer(_THIS, SDL_Window* sdl_window, + const SDL_Rect* rects, int numrects); + +extern void +MIR_DestroyWindowFramebuffer(_THIS, SDL_Window* sdl_window); + +#endif /* SDL_mirframebuffer_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ + diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.c new file mode 100644 index 0000000..5f6e38c --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.c @@ -0,0 +1,292 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "../../events/SDL_mouse_c.h" +#include "../SDL_sysvideo.h" +#include "SDL_assert.h" + +#include "SDL_mirdyn.h" + +#include "SDL_mirvideo.h" +#include "SDL_mirmouse.h" +#include "SDL_mirwindow.h" + +typedef struct +{ + MirCursorConfiguration* conf; + MirBufferStream* stream; + char const* name; +} MIR_Cursor; + +static SDL_Cursor* +MIR_CreateDefaultCursor() +{ + SDL_Cursor* cursor; + + cursor = SDL_calloc(1, sizeof(SDL_Cursor)); + if (cursor) { + + MIR_Cursor* mir_cursor = SDL_calloc(1, sizeof(MIR_Cursor)); + if (mir_cursor) { + mir_cursor->conf = NULL; + mir_cursor->stream = NULL; + mir_cursor->name = NULL; + cursor->driverdata = mir_cursor; + } + else { + SDL_OutOfMemory(); + SDL_free(cursor); + cursor = NULL; + } + } + else { + SDL_OutOfMemory(); + } + + return cursor; +} + +static void +CopySurfacePixelsToMirStream(SDL_Surface* surface, MirBufferStream* stream) +{ + char* dest, *pixels; + int i, s_w, s_h, r_stride, p_stride, bytes_per_pixel, bytes_per_row; + + MirGraphicsRegion region; + MIR_mir_buffer_stream_get_graphics_region(stream, ®ion); + + s_w = surface->w; + s_h = surface->h; + + bytes_per_pixel = surface->format->BytesPerPixel; + bytes_per_row = bytes_per_pixel * s_w; + + dest = region.vaddr; + pixels = (char*)surface->pixels; + + r_stride = region.stride; + p_stride = surface->pitch; + + for (i = 0; i < s_h; i++) + { + SDL_memcpy(dest, pixels, bytes_per_row); + dest += r_stride; + pixels += p_stride; + } +} + +static SDL_Cursor* +MIR_CreateCursor(SDL_Surface* surface, int hot_x, int hot_y) +{ + MirCursorConfiguration* conf; + MirBufferStream* stream; + + int s_w = surface->w; + int s_h = surface->h; + + MIR_Data* mir_data = (MIR_Data*)SDL_GetVideoDevice()->driverdata; + SDL_Cursor* cursor = MIR_CreateDefaultCursor(); + MIR_Cursor* mir_cursor; + + if (!cursor) { + return NULL; + } + + mir_cursor = (MIR_Cursor*)cursor->driverdata; + + stream = MIR_mir_connection_create_buffer_stream_sync(mir_data->connection, + s_w, s_h, mir_data->pixel_format, + mir_buffer_usage_software); + + conf = MIR_mir_cursor_configuration_from_buffer_stream(stream, hot_x, hot_y); + + CopySurfacePixelsToMirStream(surface, stream); + MIR_mir_buffer_stream_swap_buffers_sync(stream); + + mir_cursor->conf = conf; + mir_cursor->stream = stream; + + return cursor; +} + +static SDL_Cursor* +MIR_CreateSystemCursor(SDL_SystemCursor id) +{ + char const* cursor_name = NULL; + SDL_Cursor* cursor; + MIR_Cursor* mir_cursor; + + switch(id) { + case SDL_SYSTEM_CURSOR_ARROW: + cursor_name = MIR_mir_arrow_cursor_name; + break; + case SDL_SYSTEM_CURSOR_IBEAM: + cursor_name = MIR_mir_caret_cursor_name; + break; + case SDL_SYSTEM_CURSOR_WAIT: + cursor_name = MIR_mir_busy_cursor_name; + break; + case SDL_SYSTEM_CURSOR_CROSSHAIR: + /* Unsupported */ + cursor_name = MIR_mir_arrow_cursor_name; + break; + case SDL_SYSTEM_CURSOR_WAITARROW: + cursor_name = MIR_mir_busy_cursor_name; + break; + case SDL_SYSTEM_CURSOR_SIZENWSE: + cursor_name = MIR_mir_omnidirectional_resize_cursor_name; + break; + case SDL_SYSTEM_CURSOR_SIZENESW: + cursor_name = MIR_mir_omnidirectional_resize_cursor_name; + break; + case SDL_SYSTEM_CURSOR_SIZEWE: + cursor_name = MIR_mir_horizontal_resize_cursor_name; + break; + case SDL_SYSTEM_CURSOR_SIZENS: + cursor_name = MIR_mir_vertical_resize_cursor_name; + break; + case SDL_SYSTEM_CURSOR_SIZEALL: + cursor_name = MIR_mir_omnidirectional_resize_cursor_name; + break; + case SDL_SYSTEM_CURSOR_NO: + /* Unsupported */ + cursor_name = MIR_mir_closed_hand_cursor_name; + break; + case SDL_SYSTEM_CURSOR_HAND: + cursor_name = MIR_mir_open_hand_cursor_name; + break; + default: + SDL_assert(0); + return NULL; + } + + cursor = MIR_CreateDefaultCursor(); + if (!cursor) { + return NULL; + } + + mir_cursor = (MIR_Cursor*)cursor->driverdata; + mir_cursor->name = cursor_name; + + return cursor; +} + +static void +MIR_FreeCursor(SDL_Cursor* cursor) +{ + if (cursor) { + + if (cursor->driverdata) { + MIR_Cursor* mir_cursor = (MIR_Cursor*)cursor->driverdata; + + if (mir_cursor->conf) + MIR_mir_cursor_configuration_destroy(mir_cursor->conf); + if (mir_cursor->stream) + MIR_mir_buffer_stream_release_sync(mir_cursor->stream); + + SDL_free(mir_cursor); + } + + SDL_free(cursor); + } +} + +static int +MIR_ShowCursor(SDL_Cursor* cursor) +{ + MIR_Data* mir_data = (MIR_Data*)SDL_GetVideoDevice()->driverdata; + MIR_Window* mir_window = mir_data->current_window; + + if (cursor && cursor->driverdata) { + if (mir_window && MIR_mir_window_is_valid(mir_window->window)) { + MIR_Cursor* mir_cursor = (MIR_Cursor*)cursor->driverdata; + + if (mir_cursor->name != NULL) { + MirWindowSpec* spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_cursor_name(spec, mir_cursor->name); + MIR_mir_window_apply_spec(mir_window->window, spec); + MIR_mir_window_spec_release(spec); + } + + if (mir_cursor->conf) { + MIR_mir_window_configure_cursor(mir_window->window, mir_cursor->conf); + } + } + } + else if(mir_window && MIR_mir_window_is_valid(mir_window->window)) { + MIR_mir_window_configure_cursor(mir_window->window, NULL); + } + + return 0; +} + +static void +MIR_WarpMouse(SDL_Window* window, int x, int y) +{ + SDL_Unsupported(); +} + +static int +MIR_WarpMouseGlobal(int x, int y) +{ + return SDL_Unsupported(); +} + +static int +MIR_SetRelativeMouseMode(SDL_bool enabled) +{ + return 0; +} + +/* TODO Actually implement the cursor, need to wait for mir support */ +void +MIR_InitMouse() +{ + SDL_Mouse* mouse = SDL_GetMouse(); + + mouse->CreateCursor = MIR_CreateCursor; + mouse->ShowCursor = MIR_ShowCursor; + mouse->FreeCursor = MIR_FreeCursor; + mouse->WarpMouse = MIR_WarpMouse; + mouse->WarpMouseGlobal = MIR_WarpMouseGlobal; + mouse->CreateSystemCursor = MIR_CreateSystemCursor; + mouse->SetRelativeMouseMode = MIR_SetRelativeMouseMode; + + SDL_SetDefaultCursor(MIR_CreateDefaultCursor()); +} + +void +MIR_FiniMouse() +{ +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ + diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.h new file mode 100644 index 0000000..de32610 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirmouse.h @@ -0,0 +1,37 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_mirmouse_h_ +#define SDL_mirmouse_h_ + +extern void +MIR_InitMouse(); + +extern void +MIR_FiniMouse(); + +#endif /* SDL_mirmouse_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.c b/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.c new file mode 100644 index 0000000..7795f97 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.c @@ -0,0 +1,78 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "SDL_miropengl.h" + +#include "SDL_mirdyn.h" + +int +MIR_GL_SwapWindow(_THIS, SDL_Window* window) +{ + MIR_Window* mir_wind = window->driverdata; + + return SDL_EGL_SwapBuffers(_this, mir_wind->egl_surface); +} + +int +MIR_GL_MakeCurrent(_THIS, SDL_Window* window, SDL_GLContext context) +{ + if (window) { + EGLSurface egl_surface = ((MIR_Window*)window->driverdata)->egl_surface; + return SDL_EGL_MakeCurrent(_this, egl_surface, context); + } + + return SDL_EGL_MakeCurrent(_this, NULL, NULL); +} + +SDL_GLContext +MIR_GL_CreateContext(_THIS, SDL_Window* window) +{ + MIR_Window* mir_window = window->driverdata; + + SDL_GLContext context; + context = SDL_EGL_CreateContext(_this, mir_window->egl_surface); + + return context; +} + +int +MIR_GL_LoadLibrary(_THIS, const char* path) +{ + MIR_Data* mir_data = _this->driverdata; + + SDL_EGL_LoadLibrary(_this, path, MIR_mir_connection_get_egl_native_display(mir_data->connection), 0); + + SDL_EGL_ChooseConfig(_this); + + return 0; +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.h b/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.h new file mode 100644 index 0000000..2168f96 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_miropengl.h @@ -0,0 +1,53 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_miropengl_h_ +#define SDL_miropengl_h_ + +#include "SDL_mirwindow.h" + +#include "../SDL_egl_c.h" + +#define MIR_GL_DeleteContext SDL_EGL_DeleteContext +#define MIR_GL_GetSwapInterval SDL_EGL_GetSwapInterval +#define MIR_GL_SetSwapInterval SDL_EGL_SetSwapInterval +#define MIR_GL_UnloadLibrary SDL_EGL_UnloadLibrary +#define MIR_GL_GetProcAddress SDL_EGL_GetProcAddress + +extern int +MIR_GL_SwapWindow(_THIS, SDL_Window* window); + +extern int +MIR_GL_MakeCurrent(_THIS, SDL_Window* window, SDL_GLContext context); + +extern SDL_GLContext +MIR_GL_CreateContext(_THIS, SDL_Window* window); + +extern int +MIR_GL_LoadLibrary(_THIS, const char* path); + +#endif /* SDL_miropengl_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirsym.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirsym.h new file mode 100644 index 0000000..6e18b53 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirsym.h @@ -0,0 +1,143 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* *INDENT-OFF* */ + +#ifndef SDL_MIR_MODULE +#define SDL_MIR_MODULE(modname) +#endif + +#ifndef SDL_MIR_SYM +#define SDL_MIR_SYM(rc,fn,params) +#endif + +#ifndef SDL_MIR_SYM_CONST +#define SDL_MIR_SYM_CONST(type, name) +#endif + +SDL_MIR_MODULE(MIR_CLIENT) +SDL_MIR_SYM(MirWindow *,mir_create_window_sync,(MirWindowSpec* spec)) +SDL_MIR_SYM(MirEGLNativeWindowType,mir_buffer_stream_get_egl_native_window,(MirBufferStream *surface)) +SDL_MIR_SYM(bool,mir_buffer_stream_get_graphics_region,(MirBufferStream *stream, MirGraphicsRegion *graphics_region)) +SDL_MIR_SYM(void,mir_buffer_stream_swap_buffers_sync,(MirBufferStream *stream)) +SDL_MIR_SYM(void,mir_window_set_event_handler,(MirWindow* window, MirWindowEventCallback callback, void* context)) +SDL_MIR_SYM(MirWindowSpec*,mir_create_normal_window_spec,(MirConnection *connection, int width, int height)) +SDL_MIR_SYM(MirWindowSpec*,mir_create_window_spec,(MirConnection *connection)) +SDL_MIR_SYM(void,mir_window_spec_set_buffer_usage,(MirWindowSpec *spec, MirBufferUsage usage)) +SDL_MIR_SYM(void,mir_window_spec_set_name,(MirWindowSpec *spec, char const *name)) +SDL_MIR_SYM(void,mir_window_spec_release,(MirWindowSpec *spec)) +SDL_MIR_SYM(void,mir_window_spec_set_width,(MirWindowSpec *spec, unsigned width)) +SDL_MIR_SYM(void,mir_window_spec_set_height,(MirWindowSpec *spec, unsigned height)) +SDL_MIR_SYM(void,mir_window_spec_set_min_width,(MirWindowSpec *spec, unsigned min_width)) +SDL_MIR_SYM(void,mir_window_spec_set_min_height,(MirWindowSpec *spec, unsigned min_height)) +SDL_MIR_SYM(void,mir_window_spec_set_max_width,(MirWindowSpec *spec, unsigned max_width)) +SDL_MIR_SYM(void,mir_window_spec_set_max_height,(MirWindowSpec *spec, unsigned max_height)) +SDL_MIR_SYM(void,mir_window_spec_set_type,(MirWindowSpec *spec, MirWindowType type)) +SDL_MIR_SYM(void,mir_window_spec_set_state,(MirWindowSpec *spec, MirWindowState state)) +SDL_MIR_SYM(void,mir_window_spec_set_pointer_confinement,(MirWindowSpec *spec, MirPointerConfinementState state)) +SDL_MIR_SYM(void,mir_window_spec_set_pixel_format,(MirWindowSpec *spec, MirPixelFormat pixel_format)) +SDL_MIR_SYM(void,mir_window_spec_set_cursor_name,(MirWindowSpec *spec, char const* cursor_name)) +SDL_MIR_SYM(void,mir_window_apply_spec,(MirWindow* window, MirWindowSpec* spec)) +SDL_MIR_SYM(void,mir_window_get_parameters,(MirWindow *window, MirWindowParameters *params)) +SDL_MIR_SYM(MirBufferStream*,mir_window_get_buffer_stream,(MirWindow* window)) +SDL_MIR_SYM(MirCursorConfiguration*,mir_cursor_configuration_from_buffer_stream,(MirBufferStream const* stream, int hot_x, int hot_y)) +SDL_MIR_SYM(MirBufferStream*,mir_connection_create_buffer_stream_sync,(MirConnection *connection, int w, int h, MirPixelFormat format, MirBufferUsage usage)) +SDL_MIR_SYM(MirKeyboardAction,mir_keyboard_event_action,(MirKeyboardEvent const *event)) +SDL_MIR_SYM(xkb_keysym_t,mir_keyboard_event_key_code,(MirKeyboardEvent const *event)) +SDL_MIR_SYM(int,mir_keyboard_event_scan_code,(MirKeyboardEvent const *event)) +SDL_MIR_SYM(bool,mir_pointer_event_button_state,(MirPointerEvent const *event, MirPointerButton button)) +SDL_MIR_SYM(MirPointerButtons,mir_pointer_event_buttons,(MirPointerEvent const *event)) +SDL_MIR_SYM(MirInputDeviceId,mir_input_event_get_device_id,(MirInputEvent const* ev)) +SDL_MIR_SYM(MirTouchId,mir_touch_event_id,(MirTouchEvent const *event, size_t touch_index)) +SDL_MIR_SYM(float,mir_touch_event_axis_value,(MirTouchEvent const *event, size_t touch_index, MirTouchAxis axis)) +SDL_MIR_SYM(MirTouchAction,mir_touch_event_action,(MirTouchEvent const *event, size_t touch_index)) +SDL_MIR_SYM(MirPointerAction,mir_pointer_event_action,(MirPointerEvent const *event)) +SDL_MIR_SYM(float,mir_pointer_event_axis_value,(MirPointerEvent const *event, MirPointerAxis)) +SDL_MIR_SYM(MirEventType,mir_event_get_type,(MirEvent const *event)) +SDL_MIR_SYM(MirInputEventType,mir_input_event_get_type,(MirInputEvent const *event)) +SDL_MIR_SYM(MirInputEvent const*,mir_event_get_input_event,(MirEvent const *event)) +SDL_MIR_SYM(MirResizeEvent const*,mir_event_get_resize_event,(MirEvent const *event)) +SDL_MIR_SYM(MirKeyboardEvent const*,mir_input_event_get_keyboard_event,(MirInputEvent const *event)) +SDL_MIR_SYM(MirPointerEvent const*,mir_input_event_get_pointer_event,(MirInputEvent const *event)) +SDL_MIR_SYM(MirTouchEvent const*,mir_input_event_get_touch_event,(MirInputEvent const *event)) +SDL_MIR_SYM(MirWindowEvent const*,mir_event_get_window_event,(MirEvent const *event)) +SDL_MIR_SYM(unsigned int,mir_touch_event_point_count,(MirTouchEvent const *event)) +SDL_MIR_SYM(void,mir_connection_get_available_surface_formats,(MirConnection* connection, MirPixelFormat* formats, unsigned const int format_size, unsigned int *num_valid_formats)) +SDL_MIR_SYM(MirEGLNativeDisplayType,mir_connection_get_egl_native_display,(MirConnection *connection)) +SDL_MIR_SYM(bool,mir_connection_is_valid,(MirConnection *connection)) +SDL_MIR_SYM(void,mir_connection_release,(MirConnection *connection)) +SDL_MIR_SYM(MirPixelFormat,mir_connection_get_egl_pixel_format,(MirConnection* connection, void* egldisplay, void* eglconfig)) +SDL_MIR_SYM(MirConnection *,mir_connect_sync,(char const *server, char const *app_name)) +SDL_MIR_SYM(char const *,mir_window_get_error_message,(MirWindow *window)) +SDL_MIR_SYM(bool,mir_window_is_valid,(MirWindow *window)) +SDL_MIR_SYM(void,mir_window_release_sync,(MirWindow* window)) +SDL_MIR_SYM(void,mir_buffer_stream_release_sync,(MirBufferStream *stream)) +SDL_MIR_SYM(void,mir_window_configure_cursor,(MirWindow* window, MirCursorConfiguration const* conf)) +SDL_MIR_SYM(void,mir_cursor_configuration_destroy,(MirCursorConfiguration* conf)) +SDL_MIR_SYM(int,mir_resize_event_get_width,(MirResizeEvent const* resize_event)) +SDL_MIR_SYM(int,mir_resize_event_get_height,(MirResizeEvent const* resize_event)) +SDL_MIR_SYM(char const*,mir_connection_get_error_message,(MirConnection* connection)) +SDL_MIR_SYM(MirWindowAttrib,mir_window_event_get_attribute,(MirWindowEvent const* event)) +SDL_MIR_SYM(int,mir_window_event_get_attribute_value,(MirWindowEvent const* window_event)) +SDL_MIR_SYM(MirDisplayConfig*,mir_connection_create_display_configuration,(MirConnection* connection)) +SDL_MIR_SYM(void,mir_display_config_release,(MirDisplayConfig* config)) +SDL_MIR_SYM(int,mir_display_config_get_num_outputs,(MirDisplayConfig const* config)) +SDL_MIR_SYM(MirOutput*,mir_display_config_get_mutable_output,(MirDisplayConfig* config, size_t index)) +SDL_MIR_SYM(int,mir_output_get_num_modes,(MirOutput const* output)) +SDL_MIR_SYM(MirOutputMode const*,mir_output_get_current_mode,(MirOutput const* output)) +SDL_MIR_SYM(MirPixelFormat,mir_output_get_current_pixel_format,(MirOutput const* output)) +SDL_MIR_SYM(int,mir_output_get_position_x,(MirOutput const* output)) +SDL_MIR_SYM(int,mir_output_get_position_y,(MirOutput const* output)) +SDL_MIR_SYM(bool,mir_output_is_enabled,(MirOutput const* output)) +SDL_MIR_SYM(MirOutputConnectionState,mir_output_get_connection_state,(MirOutput const* output)) +SDL_MIR_SYM(size_t,mir_output_get_preferred_mode_index,(MirOutput const* output)) +SDL_MIR_SYM(MirOutputType,mir_output_get_type,(MirOutput const* output)) +SDL_MIR_SYM(char const*,mir_output_type_name,(MirOutputType type)) +SDL_MIR_SYM(void,mir_output_set_current_mode,(MirOutput* output, MirOutputMode const* mode)) +SDL_MIR_SYM(MirOutputMode const*,mir_output_get_mode,(MirOutput const* output, size_t index)) +SDL_MIR_SYM(int,mir_output_mode_get_width,(MirOutputMode const* mode)) +SDL_MIR_SYM(int,mir_output_mode_get_height,(MirOutputMode const* mode)) +SDL_MIR_SYM(double,mir_output_mode_get_refresh_rate,(MirOutputMode const* mode)) +SDL_MIR_SYM(bool,mir_output_is_gamma_supported,(MirOutput const* output)) +SDL_MIR_SYM(uint32_t,mir_output_get_gamma_size,(MirOutput const* output)) +SDL_MIR_SYM(void,mir_output_get_gamma,(MirOutput const* output, uint16_t* red, uint16_t* green, uint16_t* blue, uint32_t size)) +SDL_MIR_SYM(void,mir_output_set_gamma,(MirOutput* output, uint16_t const* red, uint16_t const* green, uint16_t const* blue, uint32_t size)) + +SDL_MIR_SYM_CONST(char const*,mir_omnidirectional_resize_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_busy_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_arrow_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_caret_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_vertical_resize_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_horizontal_resize_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_open_hand_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_closed_hand_cursor_name) +SDL_MIR_SYM_CONST(char const*,mir_disabled_cursor_name) + +SDL_MIR_MODULE(XKBCOMMON) +SDL_MIR_SYM(int,xkb_keysym_to_utf8,(xkb_keysym_t keysym, char *buffer, size_t size)) + +#undef SDL_MIR_MODULE +#undef SDL_MIR_SYM +#undef SDL_MIR_SYM_CONST + +/* *INDENT-ON* */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.c new file mode 100644 index 0000000..8f3a368 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.c @@ -0,0 +1,423 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "SDL_assert.h" +#include "SDL_log.h" + +#include "SDL_mirwindow.h" +#include "SDL_video.h" + +#include "SDL_mirframebuffer.h" +#include "SDL_mirmouse.h" +#include "SDL_miropengl.h" +#include "SDL_mirvideo.h" +#include "SDL_mirvulkan.h" + +#include "SDL_mirdyn.h" + +#define MIR_DRIVER_NAME "mir" + +static const Uint32 mir_pixel_format_to_sdl_format[] = { + SDL_PIXELFORMAT_UNKNOWN, /* mir_pixel_format_invalid */ + SDL_PIXELFORMAT_ABGR8888, /* mir_pixel_format_abgr_8888 */ + SDL_PIXELFORMAT_BGR888, /* mir_pixel_format_xbgr_8888 */ + SDL_PIXELFORMAT_ARGB8888, /* mir_pixel_format_argb_8888 */ + SDL_PIXELFORMAT_RGB888, /* mir_pixel_format_xrgb_8888 */ + SDL_PIXELFORMAT_BGR24, /* mir_pixel_format_bgr_888 */ + SDL_PIXELFORMAT_RGB24, /* mir_pixel_format_rgb_888 */ + SDL_PIXELFORMAT_RGB565, /* mir_pixel_format_rgb_565 */ + SDL_PIXELFORMAT_RGBA5551, /* mir_pixel_format_rgba_5551 */ + SDL_PIXELFORMAT_RGBA4444 /* mir_pixel_format_rgba_4444 */ +}; + +Uint32 +MIR_GetSDLPixelFormat(MirPixelFormat format) +{ + return mir_pixel_format_to_sdl_format[format]; +} + +static int +MIR_VideoInit(_THIS); + +static void +MIR_VideoQuit(_THIS); + +static int +MIR_GetDisplayBounds(_THIS, SDL_VideoDisplay* display, SDL_Rect* rect); + +static void +MIR_GetDisplayModes(_THIS, SDL_VideoDisplay* sdl_display); + +static int +MIR_SetDisplayMode(_THIS, SDL_VideoDisplay* sdl_display, SDL_DisplayMode* mode); + +static SDL_WindowShaper* +MIR_CreateShaper(SDL_Window* window) +{ + /* FIXME Im not sure if mir support this atm, will have to come back to this */ + return NULL; +} + +static int +MIR_SetWindowShape(SDL_WindowShaper* shaper, SDL_Surface* shape, SDL_WindowShapeMode* shape_mode) +{ + return SDL_Unsupported(); +} + +static int +MIR_ResizeWindowShape(SDL_Window* window) +{ + return SDL_Unsupported(); +} + +static int +MIR_Available() +{ + int available = 0; + + if (SDL_MIR_LoadSymbols()) { + + /* Lets ensure we can connect to the mir server */ + MirConnection* connection = MIR_mir_connect_sync(NULL, SDL_FUNCTION); + + if (!MIR_mir_connection_is_valid(connection)) { + SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Unable to connect to the mir server %s", + MIR_mir_connection_get_error_message(connection)); + + return available; + } + + MIR_mir_connection_release(connection); + + available = 1; + SDL_MIR_UnloadSymbols(); + } + + return available; +} + +static void +MIR_DeleteDevice(SDL_VideoDevice* device) +{ + SDL_free(device); + SDL_MIR_UnloadSymbols(); +} + +static void +MIR_PumpEvents(_THIS) +{ +} + +static SDL_VideoDevice* +MIR_CreateDevice(int device_index) +{ + MIR_Data* mir_data; + SDL_VideoDevice* device = NULL; + + if (!SDL_MIR_LoadSymbols()) { + return NULL; + } + + device = SDL_calloc(1, sizeof(SDL_VideoDevice)); + if (!device) { + SDL_MIR_UnloadSymbols(); + SDL_OutOfMemory(); + return NULL; + } + + mir_data = SDL_calloc(1, sizeof(MIR_Data)); + if (!mir_data) { + SDL_free(device); + SDL_MIR_UnloadSymbols(); + SDL_OutOfMemory(); + return NULL; + } + + device->driverdata = mir_data; + + /* mirvideo */ + device->VideoInit = MIR_VideoInit; + device->VideoQuit = MIR_VideoQuit; + device->GetDisplayBounds = MIR_GetDisplayBounds; + device->GetDisplayModes = MIR_GetDisplayModes; + device->SetDisplayMode = MIR_SetDisplayMode; + device->free = MIR_DeleteDevice; + + /* miropengles */ + device->GL_SwapWindow = MIR_GL_SwapWindow; + device->GL_MakeCurrent = MIR_GL_MakeCurrent; + device->GL_CreateContext = MIR_GL_CreateContext; + device->GL_DeleteContext = MIR_GL_DeleteContext; + device->GL_LoadLibrary = MIR_GL_LoadLibrary; + device->GL_UnloadLibrary = MIR_GL_UnloadLibrary; + device->GL_GetSwapInterval = MIR_GL_GetSwapInterval; + device->GL_SetSwapInterval = MIR_GL_SetSwapInterval; + device->GL_GetProcAddress = MIR_GL_GetProcAddress; + + /* mirwindow */ + device->CreateSDLWindow = MIR_CreateWindow; + device->DestroyWindow = MIR_DestroyWindow; + device->GetWindowWMInfo = MIR_GetWindowWMInfo; + device->SetWindowFullscreen = MIR_SetWindowFullscreen; + device->MaximizeWindow = MIR_MaximizeWindow; + device->MinimizeWindow = MIR_MinimizeWindow; + device->RestoreWindow = MIR_RestoreWindow; + device->ShowWindow = MIR_RestoreWindow; + device->HideWindow = MIR_HideWindow; + device->SetWindowSize = MIR_SetWindowSize; + device->SetWindowMinimumSize = MIR_SetWindowMinimumSize; + device->SetWindowMaximumSize = MIR_SetWindowMaximumSize; + device->SetWindowTitle = MIR_SetWindowTitle; + device->SetWindowGrab = MIR_SetWindowGrab; + device->SetWindowGammaRamp = MIR_SetWindowGammaRamp; + device->GetWindowGammaRamp = MIR_GetWindowGammaRamp; + + device->CreateSDLWindowFrom = NULL; + device->SetWindowIcon = NULL; + device->RaiseWindow = NULL; + device->SetWindowBordered = NULL; + device->SetWindowResizable = NULL; + device->OnWindowEnter = NULL; + device->SetWindowPosition = NULL; + + /* mirframebuffer */ + device->CreateWindowFramebuffer = MIR_CreateWindowFramebuffer; + device->UpdateWindowFramebuffer = MIR_UpdateWindowFramebuffer; + device->DestroyWindowFramebuffer = MIR_DestroyWindowFramebuffer; + + device->shape_driver.CreateShaper = MIR_CreateShaper; + device->shape_driver.SetWindowShape = MIR_SetWindowShape; + device->shape_driver.ResizeWindowShape = MIR_ResizeWindowShape; + + device->PumpEvents = MIR_PumpEvents; + + device->SuspendScreenSaver = NULL; + + device->StartTextInput = NULL; + device->StopTextInput = NULL; + device->SetTextInputRect = NULL; + + device->HasScreenKeyboardSupport = NULL; + device->ShowScreenKeyboard = NULL; + device->HideScreenKeyboard = NULL; + device->IsScreenKeyboardShown = NULL; + + device->SetClipboardText = NULL; + device->GetClipboardText = NULL; + device->HasClipboardText = NULL; + + device->ShowMessageBox = NULL; + +#if SDL_VIDEO_VULKAN + device->Vulkan_LoadLibrary = MIR_Vulkan_LoadLibrary; + device->Vulkan_UnloadLibrary = MIR_Vulkan_UnloadLibrary; + device->Vulkan_GetInstanceExtensions = MIR_Vulkan_GetInstanceExtensions; + device->Vulkan_CreateSurface = MIR_Vulkan_CreateSurface; +#endif + + return device; +} + +VideoBootStrap MIR_bootstrap = { + MIR_DRIVER_NAME, "SDL Mir video driver", + MIR_Available, MIR_CreateDevice +}; + +static SDL_DisplayMode +MIR_ConvertModeToSDLMode(MirOutputMode const* mode, MirPixelFormat format) +{ + SDL_DisplayMode sdl_mode = { + .format = MIR_GetSDLPixelFormat(format), + .w = MIR_mir_output_mode_get_width(mode), + .h = MIR_mir_output_mode_get_height(mode), + .refresh_rate = MIR_mir_output_mode_get_refresh_rate(mode), + .driverdata = NULL + }; + + return sdl_mode; +} + +static void +MIR_AddModeToDisplay(SDL_VideoDisplay* display, MirOutputMode const* mode, MirPixelFormat format) +{ + SDL_DisplayMode sdl_mode = MIR_ConvertModeToSDLMode(mode, format); + SDL_AddDisplayMode(display, &sdl_mode); +} + +static void +MIR_InitDisplayFromOutput(_THIS, MirOutput* output) +{ + SDL_VideoDisplay display; + int m; + + MirPixelFormat format = MIR_mir_output_get_current_pixel_format(output); + int num_modes = MIR_mir_output_get_num_modes(output); + SDL_DisplayMode current_mode = MIR_ConvertModeToSDLMode(MIR_mir_output_get_current_mode(output), format); + + SDL_zero(display); + + // Unfortunate cast, but SDL_AddVideoDisplay will strdup this pointer so its read-only in this case. + display.name = (char*)MIR_mir_output_type_name(MIR_mir_output_get_type(output)); + + for (m = 0; m < num_modes; m++) { + MirOutputMode const* mode = MIR_mir_output_get_mode(output, m); + MIR_AddModeToDisplay(&display, mode, format); + } + + display.desktop_mode = current_mode; + display.current_mode = current_mode; + + display.driverdata = output; + SDL_AddVideoDisplay(&display); +} + +static void +MIR_InitDisplays(_THIS) +{ + MIR_Data* mir_data = _this->driverdata; + int num_outputs = MIR_mir_display_config_get_num_outputs(mir_data->display_config); + int d; + + for (d = 0; d < num_outputs; d++) { + MirOutput* output = MIR_mir_display_config_get_mutable_output(mir_data->display_config, d); + SDL_bool enabled = MIR_mir_output_is_enabled(output); + MirOutputConnectionState state = MIR_mir_output_get_connection_state(output); + + if (enabled && state == mir_output_connection_state_connected) { + MIR_InitDisplayFromOutput(_this, output); + } + } +} + +static int +MIR_VideoInit(_THIS) +{ + MIR_Data* mir_data = _this->driverdata; + + mir_data->connection = MIR_mir_connect_sync(NULL, SDL_FUNCTION); + mir_data->current_window = NULL; + mir_data->software = SDL_FALSE; + mir_data->pixel_format = mir_pixel_format_invalid; + + if (!MIR_mir_connection_is_valid(mir_data->connection)) { + return SDL_SetError("Failed to connect to the mir server: %s", + MIR_mir_connection_get_error_message(mir_data->connection)); + } + + mir_data->display_config = MIR_mir_connection_create_display_configuration(mir_data->connection); + + MIR_InitDisplays(_this); + MIR_InitMouse(); + + return 0; +} + +static void +MIR_CleanUpDisplayConfig(_THIS) +{ + MIR_Data* mir_data = _this->driverdata; + int i; + + // SDL_VideoQuit frees the display driverdata, we own it not them + for (i = 0; i < _this->num_displays; ++i) { + _this->displays[i].driverdata = NULL; + } + + MIR_mir_display_config_release(mir_data->display_config); +} + +static void +MIR_VideoQuit(_THIS) +{ + MIR_Data* mir_data = _this->driverdata; + + MIR_CleanUpDisplayConfig(_this); + + MIR_FiniMouse(); + + MIR_GL_DeleteContext(_this, NULL); + MIR_GL_UnloadLibrary(_this); + + MIR_mir_connection_release(mir_data->connection); + + SDL_free(mir_data); + _this->driverdata = NULL; +} + +static int +MIR_GetDisplayBounds(_THIS, SDL_VideoDisplay* display, SDL_Rect* rect) +{ + MirOutput const* output = display->driverdata; + + rect->x = MIR_mir_output_get_position_x(output); + rect->y = MIR_mir_output_get_position_y(output); + rect->w = display->current_mode.w; + rect->h = display->current_mode.h; + + return 0; +} + +static void +MIR_GetDisplayModes(_THIS, SDL_VideoDisplay* display) +{ +} + +static int +MIR_SetDisplayMode(_THIS, SDL_VideoDisplay* display, SDL_DisplayMode* mode) +{ + int m; + MirOutput* output = display->driverdata; + int num_modes = MIR_mir_output_get_num_modes(output); + Uint32 sdl_format = MIR_GetSDLPixelFormat( + MIR_mir_output_get_current_pixel_format(output)); + + for (m = 0; m < num_modes; m++) { + MirOutputMode const* mir_mode = MIR_mir_output_get_mode(output, m); + int width = MIR_mir_output_mode_get_width(mir_mode); + int height = MIR_mir_output_mode_get_height(mir_mode); + double refresh_rate = MIR_mir_output_mode_get_refresh_rate(mir_mode); + + if (mode->format == sdl_format && + mode->w == width && + mode->h == height && + mode->refresh_rate == refresh_rate) { + + // FIXME Currently wont actually *set* anything. Need to wait for applying display changes + MIR_mir_output_set_current_mode(output, mir_mode); + return 0; + } + } + + return -1; +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ + diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.h new file mode 100644 index 0000000..6850bac --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirvideo.h @@ -0,0 +1,49 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_mirvideo_h__ +#define SDL_mirvideo_h__ + +#include <EGL/egl.h> +#include <mir_toolkit/mir_client_library.h> +#include "SDL_stdinc.h" + +typedef struct MIR_Window MIR_Window; + +typedef struct +{ + MirConnection* connection; + MirDisplayConfig* display_config; + MIR_Window* current_window; + SDL_bool software; + MirPixelFormat pixel_format; +} MIR_Data; + +extern Uint32 +MIR_GetSDLPixelFormat(MirPixelFormat format); + +#endif /* SDL_mirvideo_h__ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.c new file mode 100644 index 0000000..6ba3fa3 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.c @@ -0,0 +1,176 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + * @author Mark Callow, www.edgewise-consulting.com. Based on Jacob Lifshay's + * SDL_x11vulkan.c. + */ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_VULKAN && SDL_VIDEO_DRIVER_MIR + +#include "SDL_mirvideo.h" +#include "SDL_mirwindow.h" +#include "SDL_assert.h" + +#include "SDL_loadso.h" +#include "SDL_mirvulkan.h" +#include "SDL_syswm.h" + +int MIR_Vulkan_LoadLibrary(_THIS, const char *path) +{ + VkExtensionProperties *extensions = NULL; + Uint32 extensionCount = 0; + SDL_bool hasSurfaceExtension = SDL_FALSE; + SDL_bool hasMIRSurfaceExtension = SDL_FALSE; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL; + if(_this->vulkan_config.loader_handle) + return SDL_SetError("Vulkan already loaded"); + + /* Load the Vulkan loader library */ + if(!path) + path = SDL_getenv("SDL_VULKAN_LIBRARY"); + if(!path) + path = "libvulkan.so.1"; + _this->vulkan_config.loader_handle = SDL_LoadObject(path); + if(!_this->vulkan_config.loader_handle) + return -1; + SDL_strlcpy(_this->vulkan_config.loader_path, path, + SDL_arraysize(_this->vulkan_config.loader_path)); + vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_LoadFunction( + _this->vulkan_config.loader_handle, "vkGetInstanceProcAddr"); + if(!vkGetInstanceProcAddr) + goto fail; + _this->vulkan_config.vkGetInstanceProcAddr = (void *)vkGetInstanceProcAddr; + _this->vulkan_config.vkEnumerateInstanceExtensionProperties = + (void *)((PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr)( + VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties"); + if(!_this->vulkan_config.vkEnumerateInstanceExtensionProperties) + goto fail; + extensions = SDL_Vulkan_CreateInstanceExtensionsList( + (PFN_vkEnumerateInstanceExtensionProperties) + _this->vulkan_config.vkEnumerateInstanceExtensionProperties, + &extensionCount); + if(!extensions) + goto fail; + for(Uint32 i = 0; i < extensionCount; i++) + { + if(SDL_strcmp(VK_KHR_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) + hasSurfaceExtension = SDL_TRUE; + else if(SDL_strcmp(VK_KHR_MIR_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) + hasMIRSurfaceExtension = SDL_TRUE; + } + SDL_free(extensions); + if(!hasSurfaceExtension) + { + SDL_SetError("Installed Vulkan doesn't implement the " + VK_KHR_SURFACE_EXTENSION_NAME " extension"); + goto fail; + } + else if(!hasMIRSurfaceExtension) + { + SDL_SetError("Installed Vulkan doesn't implement the " + VK_KHR_MIR_SURFACE_EXTENSION_NAME "extension"); + goto fail; + } + return 0; + +fail: + SDL_UnloadObject(_this->vulkan_config.loader_handle); + _this->vulkan_config.loader_handle = NULL; + return -1; +} + +void MIR_Vulkan_UnloadLibrary(_THIS) +{ + if(_this->vulkan_config.loader_handle) + { + SDL_UnloadObject(_this->vulkan_config.loader_handle); + _this->vulkan_config.loader_handle = NULL; + } +} + +SDL_bool MIR_Vulkan_GetInstanceExtensions(_THIS, + SDL_Window *window, + unsigned *count, + const char **names) +{ + static const char *const extensionsForMir[] = { + VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_MIR_SURFACE_EXTENSION_NAME + }; + if(!_this->vulkan_config.loader_handle) + { + SDL_SetError("Vulkan is not loaded"); + return SDL_FALSE; + } + return SDL_Vulkan_GetInstanceExtensions_Helper( + count, names, SDL_arraysize(extensionsForMir), + extensionsForMir); +} + +SDL_bool MIR_Vulkan_CreateSurface(_THIS, + SDL_Window *window, + VkInstance instance, + VkSurfaceKHR *surface) +{ + MIR_Window *windowData = (MIR_Window *)window->driverdata; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = + (PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr; + PFN_vkCreateMirSurfaceKHR vkCreateMirSurfaceKHR = + (PFN_vkCreateMirSurfaceKHR)vkGetInstanceProcAddr( + (VkInstance)instance, + "vkCreateMirSurfaceKHR"); + VkMirSurfaceCreateInfoKHR createInfo; + VkResult result; + + if(!_this->vulkan_config.loader_handle) + { + SDL_SetError("Vulkan is not loaded"); + return SDL_FALSE; + } + + if(!vkCreateMirSurfaceKHR) + { + SDL_SetError(VK_KHR_MIR_SURFACE_EXTENSION_NAME + " extension is not enabled in the Vulkan instance."); + return SDL_FALSE; + } + SDL_zero(createInfo); + createInfo.sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; + createInfo.pNext = NULL; + createInfo.flags = 0; + createInfo.connection = windowData->mir_data->connection; + createInfo.mirSurface = windowData->window; + result = vkCreateMirSurfaceKHR(instance, &createInfo, + NULL, surface); + if(result != VK_SUCCESS) + { + SDL_SetError("vkCreateMirSurfaceKHR failed: %s", + SDL_Vulkan_GetResultString(result)); + return SDL_FALSE; + } + return SDL_TRUE; +} + +#endif + +/* vim: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.h new file mode 100644 index 0000000..6f40d5b --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirvulkan.h @@ -0,0 +1,52 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + * @author Mark Callow, www.edgewise-consulting.com. Based on Jacob Lifshay's + * SDL_x11vulkan.h. + */ + +#include "../../SDL_internal.h" + +#ifndef SDL_mirvulkan_h_ +#define SDL_mirvulkan_h_ + +#include "../SDL_vulkan_internal.h" +#include "../SDL_sysvideo.h" + +#if SDL_VIDEO_VULKAN && SDL_VIDEO_DRIVER_MIR + +int MIR_Vulkan_LoadLibrary(_THIS, const char *path); +void MIR_Vulkan_UnloadLibrary(_THIS); +SDL_bool MIR_Vulkan_GetInstanceExtensions(_THIS, + SDL_Window *window, + unsigned *count, + const char **names); +SDL_bool MIR_Vulkan_CreateSurface(_THIS, + SDL_Window *window, + VkInstance instance, + VkSurfaceKHR *surface); + +#endif + +#endif /* SDL_mirvulkan_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.c b/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.c new file mode 100644 index 0000000..80877ee --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.c @@ -0,0 +1,374 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#include "../../SDL_internal.h" + +#if SDL_VIDEO_DRIVER_MIR + +#include "../SDL_egl_c.h" +#include "../SDL_sysvideo.h" +#include "../../events/SDL_keyboard_c.h" + +#include "SDL_mirevents.h" +#include "SDL_mirwindow.h" + +#include "SDL_mirdyn.h" + +static int +IsMirWindowValid(MIR_Window* mir_window) +{ + if (!MIR_mir_window_is_valid(mir_window->window)) { + const char* error = MIR_mir_window_get_error_message(mir_window->window); + return SDL_SetError("Failed to create a mir surface: %s", error); + } + + return 1; +} + +static MirPixelFormat +FindValidPixelFormat(MIR_Data* mir_data) +{ + unsigned int pf_size = 32; + unsigned int valid_formats; + unsigned int f; + + MirPixelFormat formats[pf_size]; + MIR_mir_connection_get_available_surface_formats(mir_data->connection, formats, + pf_size, &valid_formats); + + for (f = 0; f < valid_formats; f++) { + MirPixelFormat cur_pf = formats[f]; + + if (cur_pf == mir_pixel_format_abgr_8888 || + cur_pf == mir_pixel_format_xbgr_8888 || + cur_pf == mir_pixel_format_argb_8888 || + cur_pf == mir_pixel_format_xrgb_8888) { + + return cur_pf; + } + } + + return mir_pixel_format_invalid; +} + +int +MIR_CreateWindow(_THIS, SDL_Window* window) +{ + MIR_Window* mir_window; + MIR_Data* mir_data; + MirPixelFormat pixel_format; + MirBufferUsage buffer_usage; + + MirWindowSpec* spec; + + mir_window = SDL_calloc(1, sizeof(MIR_Window)); + if (!mir_window) + return SDL_OutOfMemory(); + + mir_data = _this->driverdata; + window->driverdata = mir_window; + + if (window->x == SDL_WINDOWPOS_UNDEFINED) + window->x = 0; + + if (window->y == SDL_WINDOWPOS_UNDEFINED) + window->y = 0; + + mir_window->mir_data = mir_data; + mir_window->sdl_window = window; + + if (window->flags & SDL_WINDOW_OPENGL) { + pixel_format = MIR_mir_connection_get_egl_pixel_format(mir_data->connection, + _this->egl_data->egl_display, + _this->egl_data->egl_config); + } + else { + pixel_format = FindValidPixelFormat(mir_data); + } + + mir_data->pixel_format = pixel_format; + if (pixel_format == mir_pixel_format_invalid) { + return SDL_SetError("Failed to find a valid pixel format."); + } + + buffer_usage = mir_buffer_usage_hardware; + if (mir_data->software) + buffer_usage = mir_buffer_usage_software; + + spec = MIR_mir_create_normal_window_spec(mir_data->connection, + window->w, + window->h); + + MIR_mir_window_spec_set_buffer_usage(spec, buffer_usage); + MIR_mir_window_spec_set_name(spec, "Mir surface"); + MIR_mir_window_spec_set_pixel_format(spec, pixel_format); + + if (window->flags & SDL_WINDOW_INPUT_FOCUS) + SDL_SetKeyboardFocus(window); + + mir_window->window = MIR_mir_create_window_sync(spec); + MIR_mir_window_set_event_handler(mir_window->window, MIR_HandleEvent, window); + + MIR_mir_window_spec_release(spec); + + if (!MIR_mir_window_is_valid(mir_window->window)) { + return SDL_SetError("Failed to create a mir surface: %s", + MIR_mir_window_get_error_message(mir_window->window)); + } + + if (window->flags & SDL_WINDOW_OPENGL) { + EGLNativeWindowType egl_native_window = + (EGLNativeWindowType)MIR_mir_buffer_stream_get_egl_native_window( + MIR_mir_window_get_buffer_stream(mir_window->window)); + + mir_window->egl_surface = SDL_EGL_CreateSurface(_this, egl_native_window); + + if (mir_window->egl_surface == EGL_NO_SURFACE) { + return SDL_SetError("Failed to create a window surface %p", + _this->egl_data->egl_display); + } + } + else { + mir_window->egl_surface = EGL_NO_SURFACE; + } + + mir_data->current_window = mir_window; + + return 0; +} + +void +MIR_DestroyWindow(_THIS, SDL_Window* window) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + + if (mir_data) { + SDL_EGL_DestroySurface(_this, mir_window->egl_surface); + MIR_mir_window_release_sync(mir_window->window); + + mir_data->current_window = NULL; + + SDL_free(mir_window); + } + window->driverdata = NULL; +} + +SDL_bool +MIR_GetWindowWMInfo(_THIS, SDL_Window* window, SDL_SysWMinfo* info) +{ + if (info->version.major == SDL_MAJOR_VERSION && + info->version.minor == SDL_MINOR_VERSION) { + MIR_Window* mir_window = window->driverdata; + + info->subsystem = SDL_SYSWM_MIR; + info->info.mir.connection = mir_window->mir_data->connection; + // Cannot change this to window due to it being in the public API + info->info.mir.surface = mir_window->window; + + return SDL_TRUE; + } + + return SDL_FALSE; +} + +static void +UpdateMirWindowState(MIR_Data* mir_data, MIR_Window* mir_window, MirWindowState window_state) +{ + if (IsMirWindowValid(mir_window)) { + MirWindowSpec* spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_state(spec, window_state); + + MIR_mir_window_apply_spec(mir_window->window, spec); + MIR_mir_window_spec_release(spec); + } +} + +void +MIR_SetWindowFullscreen(_THIS, SDL_Window* window, + SDL_VideoDisplay* display, + SDL_bool fullscreen) +{ + if (IsMirWindowValid(window->driverdata)) { + MirWindowState state; + + if (fullscreen) { + state = mir_window_state_fullscreen; + } + else { + state = mir_window_state_restored; + } + + UpdateMirWindowState(_this->driverdata, window->driverdata, state); + } +} + +void +MIR_MaximizeWindow(_THIS, SDL_Window* window) +{ + UpdateMirWindowState(_this->driverdata, window->driverdata, mir_window_state_maximized); +} + +void +MIR_MinimizeWindow(_THIS, SDL_Window* window) +{ + UpdateMirWindowState(_this->driverdata, window->driverdata, mir_window_state_minimized); +} + +void +MIR_RestoreWindow(_THIS, SDL_Window * window) +{ + UpdateMirWindowState(_this->driverdata, window->driverdata, mir_window_state_restored); +} + +void +MIR_HideWindow(_THIS, SDL_Window* window) +{ + UpdateMirWindowState(_this->driverdata, window->driverdata, mir_window_state_hidden); +} + +void +MIR_SetWindowSize(_THIS, SDL_Window* window) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + + if (IsMirWindowValid(mir_window)) { + MirWindowSpec* spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_width (spec, window->w); + MIR_mir_window_spec_set_height(spec, window->h); + + MIR_mir_window_apply_spec(mir_window->window, spec); + } +} + +void +MIR_SetWindowMinimumSize(_THIS, SDL_Window* window) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + + if (IsMirWindowValid(mir_window)) { + MirWindowSpec* spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_min_width (spec, window->min_w); + MIR_mir_window_spec_set_min_height(spec, window->min_h); + + MIR_mir_window_apply_spec(mir_window->window, spec); + } +} + +void +MIR_SetWindowMaximumSize(_THIS, SDL_Window* window) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + + if (IsMirWindowValid(mir_window)) { + MirWindowSpec* spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_max_width (spec, window->max_w); + MIR_mir_window_spec_set_max_height(spec, window->max_h); + + MIR_mir_window_apply_spec(mir_window->window, spec); + } +} + +void +MIR_SetWindowTitle(_THIS, SDL_Window* window) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + char const* title = window->title ? window->title : ""; + MirWindowSpec* spec; + + if (IsMirWindowValid(mir_window) < 0) + return; + + spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_name(spec, title); + + MIR_mir_window_apply_spec(mir_window->window, spec); + MIR_mir_window_spec_release(spec); +} + +void +MIR_SetWindowGrab(_THIS, SDL_Window* window, SDL_bool grabbed) +{ + MIR_Data* mir_data = _this->driverdata; + MIR_Window* mir_window = window->driverdata; + MirPointerConfinementState confined = mir_pointer_unconfined; + MirWindowSpec* spec; + + if (grabbed) + confined = mir_pointer_confined_to_window; + + spec = MIR_mir_create_window_spec(mir_data->connection); + MIR_mir_window_spec_set_pointer_confinement(spec, confined); + + MIR_mir_window_apply_spec(mir_window->window, spec); + MIR_mir_window_spec_release(spec); +} + +int +MIR_SetWindowGammaRamp(_THIS, SDL_Window* window, Uint16 const* ramp) +{ + MirOutput* output = SDL_GetDisplayForWindow(window)->driverdata; + Uint32 ramp_size = 256; + + // FIXME Need to apply the changes to the output, once that public API function is around + if (MIR_mir_output_is_gamma_supported(output) == mir_output_gamma_supported) { + MIR_mir_output_set_gamma(output, + ramp + ramp_size * 0, + ramp + ramp_size * 1, + ramp + ramp_size * 2, + ramp_size); + return 0; + } + + return -1; +} + +int +MIR_GetWindowGammaRamp(_THIS, SDL_Window* window, Uint16* ramp) +{ + MirOutput* output = SDL_GetDisplayForWindow(window)->driverdata; + Uint32 ramp_size = 256; + + if (MIR_mir_output_is_gamma_supported(output) == mir_output_gamma_supported) { + if (MIR_mir_output_get_gamma_size(output) == ramp_size) { + MIR_mir_output_get_gamma(output, + ramp + ramp_size * 0, + ramp + ramp_size * 1, + ramp + ramp_size * 2, + ramp_size); + return 0; + } + } + + return -1; +} + +#endif /* SDL_VIDEO_DRIVER_MIR */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.h b/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.h new file mode 100644 index 0000000..af618f5 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/mir/SDL_mirwindow.h @@ -0,0 +1,93 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org> + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + Contributed by Brandon Schaefer, <brandon.schaefer@canonical.com> +*/ + +#ifndef SDL_mirwindow_h_ +#define SDL_mirwindow_h_ + +#include "../SDL_sysvideo.h" +#include "SDL_syswm.h" + +#include "SDL_mirvideo.h" + +struct MIR_Window { + SDL_Window* sdl_window; + MIR_Data* mir_data; + + MirWindow* window; + EGLSurface egl_surface; +}; + + +extern int +MIR_CreateWindow(_THIS, SDL_Window* window); + +extern void +MIR_DestroyWindow(_THIS, SDL_Window* window); + +extern void +MIR_SetWindowFullscreen(_THIS, SDL_Window* window, + SDL_VideoDisplay* display, + SDL_bool fullscreen); + +extern void +MIR_MaximizeWindow(_THIS, SDL_Window* window); + +extern void +MIR_MinimizeWindow(_THIS, SDL_Window* window); + +extern void +MIR_RestoreWindow(_THIS, SDL_Window* window); + +extern void +MIR_HideWindow(_THIS, SDL_Window* window); + +extern SDL_bool +MIR_GetWindowWMInfo(_THIS, SDL_Window* window, SDL_SysWMinfo* info); + +extern void +MIR_SetWindowSize(_THIS, SDL_Window* window); + +extern void +MIR_SetWindowMinimumSize(_THIS, SDL_Window* window); + +extern void +MIR_SetWindowMaximumSize(_THIS, SDL_Window* window); + +extern void +MIR_SetWindowTitle(_THIS, SDL_Window* window); + +extern void +MIR_SetWindowGrab(_THIS, SDL_Window* window, SDL_bool grabbed); + +extern int +MIR_SetWindowGammaRamp(_THIS, SDL_Window* window, Uint16 const* ramp); + +extern int +MIR_GetWindowGammaRamp(_THIS, SDL_Window* window, Uint16* ramp); + +#endif /* SDL_mirwindow_h_ */ + +/* vi: set ts=4 sw=4 expandtab: */ + |