Debian Codegraph @

src/sdl/sdl_system.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * SDL system interface.
12 *
13 * See LICENSE.txt for copyright information.
14 */
15 #include "allegro5/allegro.h"
16 #include "allegro5/internal/aintern_system.h"
17 #include "allegro5/platform/allegro_internal_sdl.h"
18 #include "allegro5/internal/aintern_timer.h"
19
20 ALLEGRO_DEBUG_CHANNEL("SDL")
21
22 static ALLEGRO_SYSTEM_INTERFACE *vt;
23
24 #define ALLEGRO_SDL_EVENT_QUEUE_SIZE 8
25
26 #ifdef DEBUGMODE
27 #define _E(x) if (type == x) return #x;
28 static char const *event_name(int type)
29 {
30 _E(SDL_FIRSTEVENT)
31 _E(SDL_QUIT)
32 _E(SDL_APP_TERMINATING)
33 _E(SDL_APP_LOWMEMORY)
34 _E(SDL_APP_WILLENTERBACKGROUND)
35 _E(SDL_APP_DIDENTERBACKGROUND)
36 _E(SDL_APP_WILLENTERFOREGROUND)
37 _E(SDL_APP_DIDENTERFOREGROUND)
38 _E(SDL_WINDOWEVENT)
39 _E(SDL_SYSWMEVENT)
40 _E(SDL_KEYDOWN)
41 _E(SDL_KEYUP)
42 _E(SDL_TEXTEDITING)
43 _E(SDL_TEXTINPUT)
44 _E(SDL_MOUSEMOTION)
45 _E(SDL_MOUSEBUTTONDOWN)
46 _E(SDL_MOUSEBUTTONUP)
47 _E(SDL_MOUSEWHEEL)
48 _E(SDL_JOYAXISMOTION)
49 _E(SDL_JOYBALLMOTION)
50 _E(SDL_JOYHATMOTION)
51 _E(SDL_JOYBUTTONDOWN)
52 _E(SDL_JOYBUTTONUP)
53 _E(SDL_JOYDEVICEADDED)
54 _E(SDL_JOYDEVICEREMOVED)
55 _E(SDL_CONTROLLERAXISMOTION)
56 _E(SDL_CONTROLLERBUTTONDOWN)
57 _E(SDL_CONTROLLERBUTTONUP)
58 _E(SDL_CONTROLLERDEVICEADDED)
59 _E(SDL_CONTROLLERDEVICEREMOVED)
60 _E(SDL_CONTROLLERDEVICEREMAPPED)
61 _E(SDL_FINGERDOWN)
62 _E(SDL_FINGERUP)
63 _E(SDL_FINGERMOTION)
64 _E(SDL_DOLLARGESTURE)
65 _E(SDL_DOLLARRECORD)
66 _E(SDL_MULTIGESTURE)
67 _E(SDL_CLIPBOARDUPDATE)
68 _E(SDL_DROPFILE)
69 _E(SDL_RENDER_TARGETS_RESET)
70 _E(SDL_USEREVENT)
71 return "(unknown)";
72 }
73 #undef _E
74 #endif
75
76 static void sdl_heartbeat(void)
77 {
78 SDL_Event events[ALLEGRO_SDL_EVENT_QUEUE_SIZE];
79 ALLEGRO_SYSTEM_SDL *s = (void *)al_get_system_driver();
80 al_lock_mutex(s->mutex);
81 SDL_PumpEvents();
82 int n, i;
83 while ((n = SDL_PeepEvents(events, ALLEGRO_SDL_EVENT_QUEUE_SIZE, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) > 0) {
84 for (i = 0; i < n; i++) {
85 //printf("event %s\n", event_name(events[i].type));
86 switch (events[i].type) {
87 case SDL_KEYDOWN:
88 case SDL_KEYUP:
89 case SDL_TEXTINPUT:
90 _al_sdl_keyboard_event(&events[i]);
91 break;
92 case SDL_MOUSEMOTION:
93 case SDL_MOUSEBUTTONDOWN:
94 case SDL_MOUSEBUTTONUP:
95 case SDL_MOUSEWHEEL:
96 _al_sdl_mouse_event(&events[i]);
97 break;
98 case SDL_FINGERDOWN:
99 case SDL_FINGERMOTION:
100 case SDL_FINGERUP:
101 _al_sdl_touch_input_event(&events[i]);
102 break;
103 case SDL_JOYAXISMOTION:
104 case SDL_JOYBUTTONDOWN:
105 case SDL_JOYBUTTONUP:
106 case SDL_JOYDEVICEADDED:
107 case SDL_JOYDEVICEREMOVED:
108 case SDL_CONTROLLERAXISMOTION:
109 case SDL_CONTROLLERBUTTONDOWN:
110 case SDL_CONTROLLERBUTTONUP:
111 case SDL_CONTROLLERDEVICEADDED:
112 case SDL_CONTROLLERDEVICEREMOVED:
113 _al_sdl_joystick_event(&events[i]);
114 break;
115 case SDL_QUIT:
116 _al_sdl_display_event(&events[i]);
117 break;
118 case SDL_WINDOWEVENT:
119 switch (events[i].window.event) {
120 case SDL_WINDOWEVENT_ENTER:
121 case SDL_WINDOWEVENT_LEAVE:
122 _al_sdl_mouse_event(&events[i]);
123 break;
124 case SDL_WINDOWEVENT_FOCUS_GAINED:
125 case SDL_WINDOWEVENT_FOCUS_LOST:
126 _al_sdl_display_event(&events[i]);
127 _al_sdl_keyboard_event(&events[i]);
128 break;
129 case SDL_WINDOWEVENT_CLOSE:
130 case SDL_WINDOWEVENT_RESIZED:
131 _al_sdl_display_event(&events[i]);
132 break;
133 }
134 }
135 }
136 }
137 #ifdef __EMSCRIPTEN__
138 double t = al_get_time();
139 double interval = t - s->timer_time;
140 _al_timer_thread_handle_tick(interval);
141 s->timer_time = t;
142 #endif
143 al_unlock_mutex(s->mutex);
144 }
145
146 static ALLEGRO_SYSTEM *sdl_initialize(int flags)
147 {
148 (void)flags;
149 ALLEGRO_SYSTEM_SDL *s = al_calloc(1, sizeof *s);
150 s->system.vt = vt;
151
152 // TODO: map allegro flags to sdl flags.
153 unsigned int sdl_flags = SDL_INIT_EVERYTHING;
154 #ifdef __EMSCRIPTEN__
155 // SDL currently does not support haptic feedback for emscripten.
156 sdl_flags &= ~SDL_INIT_HAPTIC;
157 #endif
158 if (SDL_Init(sdl_flags) < 0) {
159 ALLEGRO_ERROR("SDL_Init failed: %s", SDL_GetError());
160 return NULL;
161 }
162
163 _al_vector_init(&s->system.displays, sizeof (ALLEGRO_DISPLAY_SDL *));
164
165 return &s->system;
166 }
167
168 static void sdl_heartbeat_init(void)
169 {
170 ALLEGRO_SYSTEM_SDL *s = (void *)al_get_system_driver();
171
172 /* This cannot be done in sdl_initialize because the threading system
173 * requires a completed ALLEGRO_SYSTEM which only exists after the
174 * function returns. This function on the other hand will get called
175 * once the system was created.
176 */
177 s->mutex = al_create_mutex();
178
179 #ifdef __EMSCRIPTEN__
180 s->timer_time = al_get_time();
181 #endif
182 }
183
184 static void sdl_shutdown_system(void)
185 {
186 ALLEGRO_SYSTEM_SDL *s = (void *)al_get_system_driver();
187
188 /* Close all open displays. */
189 while (_al_vector_size(&s->system.displays) > 0) {
190 ALLEGRO_DISPLAY **dptr = _al_vector_ref(&s->system.displays, 0);
191 ALLEGRO_DISPLAY *d = *dptr;
192 al_destroy_display(d);
193 }
194 _al_vector_free(&s->system.displays);
195
196 al_destroy_mutex(s->mutex);
197 al_free(s);
198 SDL_Quit();
199 }
200
201 static ALLEGRO_PATH *sdl_get_path(int id)
202 {
203 ALLEGRO_PATH *p = NULL;
204 char* dir;
205 switch (id) {
206 case ALLEGRO_TEMP_PATH:
207 case ALLEGRO_USER_DOCUMENTS_PATH:
208 case ALLEGRO_USER_DATA_PATH:
209 case ALLEGRO_USER_SETTINGS_PATH:
210 dir = SDL_GetPrefPath(al_get_org_name(), al_get_app_name());
211 p = al_create_path_for_directory(dir);
212 if (id == ALLEGRO_TEMP_PATH) {
213 al_append_path_component(p, "tmp");
214 }
215 SDL_free(dir);
216 break;
217 case ALLEGRO_RESOURCES_PATH:
218 case ALLEGRO_EXENAME_PATH:
219 case ALLEGRO_USER_HOME_PATH:
220 dir = SDL_GetBasePath();
221 p = al_create_path_for_directory(dir);
222 if (id == ALLEGRO_EXENAME_PATH) {
223 al_set_path_filename(p, al_get_app_name());
224 }
225 SDL_free(dir);
226 break;
227 }
228 return p;
229 }
230
231 static ALLEGRO_DISPLAY_INTERFACE *sdl_get_display_driver(void)
232 {
233 return _al_sdl_display_driver();
234 }
235
236 static ALLEGRO_KEYBOARD_DRIVER *sdl_get_keyboard_driver(void)
237 {
238 return _al_sdl_keyboard_driver();
239 }
240
241 static ALLEGRO_MOUSE_DRIVER *sdl_get_mouse_driver(void)
242 {
243 return _al_sdl_mouse_driver();
244 }
245
246 static ALLEGRO_TOUCH_INPUT_DRIVER *sdl_get_touch_input_driver(void)
247 {
248 return _al_sdl_touch_input_driver();
249 }
250
251 static ALLEGRO_JOYSTICK_DRIVER *sdl_get_joystick_driver(void)
252 {
253 return _al_sdl_joystick_driver();
254 }
255
256 #define ADD(allegro, sdl) if (sdl_format == \
257 SDL_PIXELFORMAT_##sdl) return ALLEGRO_PIXEL_FORMAT_##allegro;
258 int _al_sdl_get_allegro_pixel_format(int sdl_format) {
259 ADD(ARGB_8888, ARGB8888)
260 ADD(RGBA_8888, RGBA8888)
261 ADD(ABGR_8888, ABGR8888)
262 return 0;
263 }
264 #undef ADD
265
266 #define ADD(allegro, sdl) if (allegro_format == \
267 ALLEGRO_PIXEL_FORMAT_##allegro) return SDL_PIXELFORMAT_##sdl;
268 int _al_sdl_get_sdl_pixel_format(int allegro_format) {
269 ADD(ANY, ABGR8888)
270 ADD(ANY_NO_ALPHA, ABGR8888)
271 ADD(ANY_WITH_ALPHA, ABGR8888)
272 ADD(ANY_32_NO_ALPHA, ABGR8888)
273 ADD(ANY_32_WITH_ALPHA, ABGR8888)
274 ADD(ARGB_8888, ARGB8888)
275 ADD(RGBA_8888, RGBA8888)
276 ADD(ABGR_8888, ABGR8888)
277 ADD(ABGR_8888_LE, ABGR8888)
278 return 0;
279 }
280 #undef ADD
281
282
283 static int sdl_get_num_video_adapters(void)
284 {
285 return SDL_GetNumVideoDisplays();
286 }
287
288 static bool sdl_get_monitor_info(int adapter, ALLEGRO_MONITOR_INFO *info)
289 {
290 SDL_Rect rect;
291 if (SDL_GetDisplayBounds(adapter, &rect) < 0)
292 return false;
293 info->x1 = rect.x;
294 info->y1 = rect.y;
295 info->x2 = rect.x + rect.w;
296 info->y2 = rect.y + rect.h;
297 return true;
298 }
299
300 static ALLEGRO_MOUSE_CURSOR* sdl_create_mouse_cursor(ALLEGRO_BITMAP *sprite, int xfocus, int yfocus)
301 {
302 SDL_Cursor *cursor;
303 ALLEGRO_MOUSE_CURSOR_SDL *sdl_cursor;
304
305 int w = al_get_bitmap_width(sprite);
306 int h = al_get_bitmap_height(sprite);
307 int data_size = w * h * 4;
308
309 unsigned char* data = al_malloc(data_size * sizeof(data[0]));
310
311 Uint32 rmask, gmask, bmask, amask;
312 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
313 rmask = 0xff000000;
314 gmask = 0x00ff0000;
315 bmask = 0x0000ff00;
316 amask = 0x000000ff;
317 #else // little endian, like x86
318 rmask = 0x000000ff;
319 gmask = 0x0000ff00;
320 bmask = 0x00ff0000;
321 amask = 0xff000000;
322 #endif
323
324 ALLEGRO_LOCKED_REGION *lock = al_lock_bitmap(sprite, ALLEGRO_PIXEL_FORMAT_ABGR_8888, ALLEGRO_LOCK_READONLY);
325 if (lock) {
326 int i = 0, y = 0;
327 for (y = 0; y < h; y++) {
328 int x = 0;
329 for (x = 0; x < w; x++) {
330 ALLEGRO_COLOR c = al_get_pixel(sprite, x, y);
331 al_unmap_rgba(c, data+i, data+i+1, data+i+2, data+i+3);
332 i += 4;
333 }
334 }
335 al_unlock_bitmap(sprite);
336
337 SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(data, w, h, 4 * 8, w * 4, rmask, gmask, bmask, amask);
338 cursor = SDL_CreateColorCursor(icon, xfocus, yfocus);
339 SDL_FreeSurface(icon);
340 }
341
342 al_free(data);
343 if (!cursor) {
344 return NULL;
345 }
346
347 sdl_cursor = al_malloc(sizeof *sdl_cursor);
348 if (!sdl_cursor) {
349 SDL_FreeCursor(cursor);
350 return NULL;
351 }
352
353 sdl_cursor->cursor = cursor;
354 return (ALLEGRO_MOUSE_CURSOR *)sdl_cursor;
355 }
356
357 static void sdl_destroy_mouse_cursor(ALLEGRO_MOUSE_CURSOR *cursor)
358 {
359 ALLEGRO_MOUSE_CURSOR_SDL *sdl_cursor = (ALLEGRO_MOUSE_CURSOR_SDL *) cursor;
360 ASSERT(sdl_cursor);
361 SDL_FreeCursor(sdl_cursor->cursor);
362 al_free(sdl_cursor);
363 }
364
365 static int sdl_get_monitor_dpi(int adapter)
366 {
367 float ddpi, hdpi, vdpi;
368 if (SDL_GetDisplayDPI(adapter, &ddpi, &hdpi, &vdpi) < 0)
369 return 72; // we can't indicate "unknown" so return something reasonable
370 return hdpi;
371 }
372
373 static int sdl_get_num_display_modes(void)
374 {
375 int i = al_get_new_display_adapter();
376 if (i < 0)
377 i = 0;
378 return SDL_GetNumDisplayModes(i);
379 }
380
381 static ALLEGRO_DISPLAY_MODE *sdl_get_display_mode(int index, ALLEGRO_DISPLAY_MODE *mode)
382 {
383 SDL_DisplayMode sdl_mode;
384 int i = al_get_new_display_adapter();
385 if (i < 0)
386 i = 0;
387 if (SDL_GetDisplayMode(i, index, &sdl_mode) < 0)
388 return NULL;
389 mode->width = sdl_mode.w;
390 mode->height = sdl_mode.h;
391 mode->format = _al_sdl_get_allegro_pixel_format(sdl_mode.format);
392 mode->refresh_rate = sdl_mode.refresh_rate;
393 return mode;
394 }
395
396 static bool sdl_inhibit_screensaver(bool inhibit)
397 {
398 if (inhibit) {
399 SDL_DisableScreenSaver();
400 } else {
401 SDL_EnableScreenSaver();
402 }
403 return SDL_IsScreenSaverEnabled() != inhibit;
404 }
405
406 /* Internal function to get a reference to this driver. */
407 ALLEGRO_SYSTEM_INTERFACE *_al_sdl_system_driver(void)
408 {
409 if (vt)
410 return vt;
411
412 vt = al_calloc(1, sizeof *vt);
413 vt->id = ALLEGRO_SYSTEM_ID_SDL;
414 vt->initialize = sdl_initialize;
415 vt->get_display_driver = sdl_get_display_driver;
416 vt->get_keyboard_driver = sdl_get_keyboard_driver;
417 vt->get_mouse_driver = sdl_get_mouse_driver;
418 vt->get_touch_input_driver = sdl_get_touch_input_driver;
419 vt->get_joystick_driver = sdl_get_joystick_driver;
420 //vt->get_haptic_driver = sdl_get_haptic_driver;
421 vt->get_num_display_modes = sdl_get_num_display_modes;
422 vt->get_display_mode = sdl_get_display_mode;
423 vt->shutdown_system = sdl_shutdown_system;
424 vt->get_num_video_adapters = sdl_get_num_video_adapters;
425 vt->get_monitor_info = sdl_get_monitor_info;
426 vt->create_mouse_cursor = sdl_create_mouse_cursor;
427 vt->get_monitor_dpi = sdl_get_monitor_dpi;
428 vt->destroy_mouse_cursor = sdl_destroy_mouse_cursor;
429 /*vt->get_cursor_position = sdl_get_cursor_position;
430 vt->grab_mouse = sdl_grab_mouse;
431 vt->ungrab_mouse = sdl_ungrab_mouse;*/
432 vt->get_path = sdl_get_path;
433 vt->inhibit_screensaver = sdl_inhibit_screensaver;
434 /*vt->thread_init = sdl_thread_init;
435 vt->thread_exit = sdl_thread_exit;
436 vt->open_library = sdl_open_library;
437 vt->import_symbol = sdl_import_symbol;
438 vt->close_library = sdl_close_library;*/
439 vt->heartbeat = sdl_heartbeat;
440 vt->heartbeat_init = sdl_heartbeat_init;
441 vt->get_time = _al_sdl_get_time;
442 vt->rest = _al_sdl_rest;
443 vt->init_timeout = _al_sdl_init_timeout;
444
445 return vt;
446 }
447
448 void _al_register_system_interfaces(void)
449 {
450 ALLEGRO_SYSTEM_INTERFACE **add;
451 add = _al_vector_alloc_back(&_al_system_interfaces);
452 *add = _al_sdl_system_driver();
453 }