taisei/src/events.c
2024-05-17 14:11:48 +02:00

524 lines
14 KiB
C

/*
* This software is licensed under the terms of the MIT License.
* See COPYING for further information.
* ---
* Copyright (c) 2011-2024, Lukas Weber <laochailan@web.de>.
* Copyright (c) 2012-2024, Andrei Alexeyev <akari@taisei-project.org>.
*/
#include "events.h"
#include "config.h"
#include "global.h"
#include "transition.h"
#include "video.h"
static hrtime_t keyrepeat_paused_until;
static int global_handlers_lock = 0;
static DYNAMIC_ARRAY(EventHandler) global_handlers_pending;
static DYNAMIC_ARRAY(EventHandler) global_handlers;
static DYNAMIC_ARRAY(SDL_Event) deferred_events;
uint32_t sdl_first_user_event;
static void events_register_default_handlers(void);
static void events_unregister_default_handlers(void);
#define MAX_ACTIVE_HANDLERS 32
/*
* Public API
*/
void events_init(void) {
sdl_first_user_event = SDL_RegisterEvents(NUM_TAISEI_EVENTS);
if(sdl_first_user_event == (uint32_t)-1) {
char *s =
"You have exhausted the SDL userevent pool. "
"How you managed that is beyond me, but congratulations.";
log_fatal("%s", s);
}
SDL_EventState(SDL_MOUSEMOTION, SDL_DISABLE);
events_register_default_handlers();
}
void events_shutdown(void) {
events_unregister_default_handlers();
dynarray_free_data(&deferred_events);
#ifdef DEBUG
dynarray_foreach_elem(&global_handlers, EventHandler *h, {
log_warn("Global event handler was not unregistered: %p", UNION_CAST(EventHandlerProc, void*, h->proc));
});
#endif
dynarray_free_data(&global_handlers);
dynarray_free_data(&global_handlers_pending);
}
static bool events_invoke_handler(SDL_Event *event, EventHandler *handler) {
assert(handler->proc != NULL);
assert(global_handlers_lock > 0);
if(!handler->event_type || handler->event_type == event->type) {
bool result = handler->proc(event, handler->arg);
return result;
}
return false;
}
static inline int prio_index(EventPriority prio) {
return prio - EPRIO_FIRST;
}
void events_register_handler(EventHandler *handler) {
assert(sdl_first_user_event > 0);
assert(handler->proc != NULL);
assert(handler->priority >= EPRIO_FIRST);
assert(handler->priority <= EPRIO_LAST);
if(global_handlers_lock) {
dynarray_append(&global_handlers_pending, *handler);
} else {
dynarray_append(&global_handlers, *handler);
}
// don't bother sorting, since most of the time we will need to re-sort it
// together with local handlers when polling
}
static bool hfilter_remove_pending(const void *pelem, void *ignored) {
const EventHandler *h = pelem;
return !h->_private.removal_pending;
}
void events_unregister_handler(EventHandlerProc proc) {
dynarray_foreach_elem(&global_handlers, EventHandler *h, {
if(h->proc == proc && !h->_private.removal_pending) {
h->_private.removal_pending = true;
break;
}
});
if(global_handlers_lock) {
assert(global_handlers_lock > 0);
} else {
dynarray_filter(&global_handlers, hfilter_remove_pending, NULL);
}
}
static void events_apply_flags(EventFlags flags) {
if(flags & EFLAG_TEXT) {
if(!SDL_IsTextInputActive()) {
SDL_StartTextInput();
}
} else {
if(SDL_IsTextInputActive()) {
SDL_StopTextInput();
}
}
TaiseiEvent type;
for(type = TE_MENU_FIRST; type <= TE_MENU_LAST; ++type) {
SDL_EventState(MAKE_TAISEI_EVENT(type), (bool)(flags & EFLAG_MENU));
}
for(type = TE_GAME_FIRST; type <= TE_GAME_LAST; ++type) {
SDL_EventState(MAKE_TAISEI_EVENT(type), (bool)(flags & EFLAG_GAME));
}
}
static int enqueue_event_handlers(int max, EventHandler *queue[max], EventHandler local_handlers[]) {
// counting sort!
int cnt = 0;
int pcount[NUM_EPRIOS] = { 0 };
EventHandler *temp[max];
assert(global_handlers.num_elements <= max);
dynarray_foreach_elem(&global_handlers, EventHandler *h, {
++pcount[prio_index(h->priority)];
temp[cnt++] = h;
});
if(local_handlers) {
for(EventHandler *h = local_handlers; h->proc; ++h) {
int pidx = prio_index(h->priority);
assert((uint)pidx < ARRAY_SIZE(pcount));
++pcount[pidx];
temp[cnt++] = h;
assert(cnt < max);
}
}
for(int i = 0, total = 0; i < NUM_EPRIOS; ++i) {
int t = total;
total += pcount[i];
pcount[i] = t;
}
for(int i = 0; i < cnt; ++i) {
EventHandler *h = temp[i];
int p = prio_index(h->priority);
queue[pcount[p]] = h;
++pcount[p];
}
return cnt;
}
static void push_event(SDL_Event *e) {
/*
* NOTE: The SDL_PushEvent() function is a wrapper around SDL_PeepEvents that also sets the
* timestamp field and calls the event filter function and event watchers. We don't use any of
* that, and setting the timestamp involves an expensive system call, so avoid it.
*/
if(UNLIKELY(SDL_PeepEvents(e, 1, SDL_ADDEVENT, 0, 0) <= 0)) {
log_sdl_error(LOG_ERROR, "SDL_PeepEvents");
}
}
void events_poll(EventHandler *handlers, EventFlags flags) {
events_apply_flags(flags);
events_emit(TE_FRAME, 0, NULL, NULL);
++global_handlers_lock;
EventHandler *hqueue[MAX_ACTIVE_HANDLERS];
int hqueue_size = enqueue_event_handlers(ARRAY_SIZE(hqueue), hqueue, handlers);
for(;;) {
if(!(flags & EFLAG_NOPUMP)) {
SDL_PumpEvents();
}
SDL_Event events[8];
int nevents = SDL_PeepEvents(events, ARRAY_SIZE(events), SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT);
if(UNLIKELY(nevents < 0)) {
log_sdl_error(LOG_ERROR, "SDL_PeepEvents");
}
if(nevents == 0) {
break;
}
for(SDL_Event *e = events, *end = events + nevents; e < end; ++e) {
for(int i = 0; i < hqueue_size; ++i) {
EventHandler *h = NOT_NULL(hqueue[i]);
if(h->_private.removal_pending) {
continue;
}
if(events_invoke_handler(e, h)) {
break;
}
}
}
}
if(--global_handlers_lock == 0) {
dynarray_filter(&global_handlers, hfilter_remove_pending, NULL);
dynarray_ensure_capacity(&global_handlers, global_handlers.num_elements + global_handlers_pending.num_elements);
dynarray_foreach_elem(&global_handlers_pending, EventHandler *h, {
*dynarray_append(&global_handlers) = *h;
});
global_handlers_pending.num_elements = 0;
}
dynarray_foreach_elem(&deferred_events, SDL_Event *evt, {
push_event(evt);
});
deferred_events.num_elements = 0;
}
void events_emit(TaiseiEvent type, int32_t code, void *data1, void *data2) {
assert(TAISEI_EVENT_VALID(type));
uint32_t sdltype = MAKE_TAISEI_EVENT(type);
assert(IS_TAISEI_EVENT(sdltype));
if(!SDL_EventState(sdltype, SDL_QUERY)) {
return;
}
SDL_Event event = { 0 };
event.type = sdltype;
event.user.code = code;
event.user.data1 = data1;
event.user.data2 = data2;
push_event(&event);
}
void events_defer(SDL_Event *evt) {
dynarray_append(&deferred_events, *evt);
}
void events_pause_keyrepeat(void) {
// workaround for SDL bug
// https://bugzilla.libsdl.org/show_bug.cgi?id=3287
keyrepeat_paused_until = time_get() + HRTIME_RESOLUTION / 4;
}
/*
* Default handlers
*/
static bool events_handler_quit(SDL_Event *event, void *arg);
static bool events_handler_keyrepeat_workaround(SDL_Event *event, void *arg);
static bool events_handler_clipboard(SDL_Event *event, void *arg);
static bool events_handler_hotkeys(SDL_Event *event, void *arg);
static bool events_handler_key_down(SDL_Event *event, void *arg);
static bool events_handler_key_up(SDL_Event *event, void *arg);
attr_unused
static bool events_handler_debug_winevt(SDL_Event *event, void *arg) {
// copied from SDL wiki almost verbatim
if(event->type == SDL_WINDOWEVENT) {
switch(event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
log_info("Window %d shown", event->window.windowID);
break;
case SDL_WINDOWEVENT_HIDDEN:
log_info("Window %d hidden", event->window.windowID);
break;
case SDL_WINDOWEVENT_EXPOSED:
log_info("Window %d exposed", event->window.windowID);
break;
case SDL_WINDOWEVENT_MOVED:
log_info("Window %d moved to %d,%d", event->window.windowID, event->window.data1, event->window.data2);
break;
case SDL_WINDOWEVENT_RESIZED:
log_info("Window %d resized to %dx%d", event->window.windowID, event->window.data1, event->window.data2);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
log_info("Window %d size changed to %dx%d", event->window.windowID, event->window.data1, event->window.data2);
break;
case SDL_WINDOWEVENT_MINIMIZED:
log_info("Window %d minimized", event->window.windowID);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
log_info("Window %d maximized", event->window.windowID);
break;
case SDL_WINDOWEVENT_RESTORED:
log_info("Window %d restored", event->window.windowID);
break;
case SDL_WINDOWEVENT_ENTER:
log_info("Mouse entered window %d", event->window.windowID);
break;
case SDL_WINDOWEVENT_LEAVE:
log_info("Mouse left window %d", event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
log_info("Window %d gained keyboard focus", event->window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
log_info("Window %d lost keyboard focus", event->window.windowID);
break;
case SDL_WINDOWEVENT_CLOSE:
log_info("Window %d closed", event->window.windowID);
break;
case SDL_WINDOWEVENT_TAKE_FOCUS:
log_info("Window %d is offered a focus", event->window.windowID);
break;
case SDL_WINDOWEVENT_HIT_TEST:
log_info("Window %d has a special hit test", event->window.windowID);
break;
default:
log_warn("Window %d got unknown event %d", event->window.windowID, event->window.event);
break;
}
}
return false;
}
static EventHandler default_handlers[] = {
#ifdef DEBUG_WINDOW_EVENTS
{ .proc = events_handler_debug_winevt, .priority = EPRIO_SYSTEM, .event_type = SDL_WINDOWEVENT },
#endif
{ .proc = events_handler_quit, .priority = EPRIO_SYSTEM, .event_type = SDL_QUIT },
{ .proc = events_handler_keyrepeat_workaround, .priority = EPRIO_CAPTURE, .event_type = 0 },
{ .proc = events_handler_clipboard, .priority = EPRIO_CAPTURE, .event_type = SDL_KEYDOWN },
{ .proc = events_handler_hotkeys, .priority = EPRIO_HOTKEYS, .event_type = SDL_KEYDOWN },
{ .proc = events_handler_key_down, .priority = EPRIO_TRANSLATION, .event_type = SDL_KEYDOWN },
{ .proc = events_handler_key_up, .priority = EPRIO_TRANSLATION, .event_type = SDL_KEYUP },
{NULL}
};
static void events_register_default_handlers(void) {
for(EventHandler *h = default_handlers; h->proc; ++h) {
events_register_handler(h);
}
}
static void events_unregister_default_handlers(void) {
for(EventHandler *h = default_handlers; h->proc; ++h) {
events_unregister_handler(h->proc);
}
}
static bool events_handler_quit(SDL_Event *event, void *arg) {
taisei_quit();
return true;
}
static bool events_handler_keyrepeat_workaround(SDL_Event *event, void *arg) {
hrtime_t timenow = time_get();
if(event->type != SDL_KEYDOWN) {
uint32_t te = TAISEI_EVENT(event->type);
if(te < TE_MENU_FIRST || te > TE_MENU_LAST) {
return false;
}
}
if(timenow < keyrepeat_paused_until) {
log_debug(
"Prevented a potentially bogus key repeat (%"PRIuTIME" remaining). "
"This is an SDL bug. See https://bugzilla.libsdl.org/show_bug.cgi?id=3287",
keyrepeat_paused_until - timenow
);
return true;
}
return false;
}
static bool events_handler_clipboard(SDL_Event *event, void *arg) {
if(!SDL_IsTextInputActive()) {
return false;
}
if(event->key.keysym.mod & KMOD_CTRL && event->key.keysym.scancode == SDL_SCANCODE_V) {
if(SDL_HasClipboardText()) {
memset(event, 0, sizeof(SDL_Event));
event->type = MAKE_TAISEI_EVENT(TE_CLIPBOARD_PASTE);
} else {
return true;
}
}
return false;
}
static bool events_handler_key_down(SDL_Event *event, void *arg) {
SDL_Scancode scan = event->key.keysym.scancode;
bool repeat = event->key.repeat;
if(video_get_backend() == VIDEO_BACKEND_EMSCRIPTEN && scan == SDL_SCANCODE_TAB) {
scan = SDL_SCANCODE_ESCAPE;
}
/*
* Emit menu events
*/
struct eventmap_s { int scancode; TaiseiEvent event; } menu_event_map[] = {
// order matters
// handle all the hardcoded controls first to prevent accidentally overriding them with unusable ones
{ SDL_SCANCODE_DOWN, TE_MENU_CURSOR_DOWN },
{ SDL_SCANCODE_UP, TE_MENU_CURSOR_UP },
{ SDL_SCANCODE_RIGHT, TE_MENU_CURSOR_RIGHT },
{ SDL_SCANCODE_LEFT, TE_MENU_CURSOR_LEFT },
{ SDL_SCANCODE_RETURN, TE_MENU_ACCEPT },
{ SDL_SCANCODE_ESCAPE, TE_MENU_ABORT },
{ config_get_int(CONFIG_KEY_DOWN), TE_MENU_CURSOR_DOWN },
{ config_get_int(CONFIG_KEY_UP), TE_MENU_CURSOR_UP },
{ config_get_int(CONFIG_KEY_RIGHT), TE_MENU_CURSOR_RIGHT },
{ config_get_int(CONFIG_KEY_LEFT), TE_MENU_CURSOR_LEFT },
{ config_get_int(CONFIG_KEY_SHOT), TE_MENU_ACCEPT },
{ config_get_int(CONFIG_KEY_BOMB), TE_MENU_ABORT },
{SDL_SCANCODE_UNKNOWN, -1}
};
if(!repeat || transition.state == TRANS_IDLE) {
for(struct eventmap_s *m = menu_event_map; m->scancode != SDL_SCANCODE_UNKNOWN; ++m) {
if(scan == m->scancode && (!repeat || m->event != TE_MENU_ACCEPT)) {
events_emit(m->event, 0, (void*)(intptr_t)INDEV_KEYBOARD, NULL);
break;
}
}
}
/*
* Emit game events
*/
if(!repeat) {
if(scan == config_get_int(CONFIG_KEY_PAUSE) || scan == SDL_SCANCODE_ESCAPE) {
events_emit(TE_GAME_PAUSE, 0, NULL, NULL);
} else {
int key = config_key_from_scancode(scan);
if(key >= 0) {
events_emit(TE_GAME_KEY_DOWN, key, (void*)(intptr_t)INDEV_KEYBOARD, NULL);
}
}
}
return false;
}
static bool events_handler_key_up(SDL_Event *event, void *arg) {
SDL_Scancode scan = event->key.keysym.scancode;
/*
* Emit game events
*/
int key = config_key_from_scancode(scan);
if(key >= 0) {
events_emit(TE_GAME_KEY_UP, key, (void*)(intptr_t)INDEV_KEYBOARD, NULL);
}
return false;
}
static bool events_handler_hotkeys(SDL_Event *event, void *arg) {
if(event->key.repeat) {
return false;
}
SDL_Scancode scan = event->key.keysym.scancode;
SDL_Keymod mod = event->key.keysym.mod;
if(scan == config_get_int(CONFIG_KEY_SCREENSHOT)) {
bool viewport_only = (mod & KMOD_ALT);
video_take_screenshot(viewport_only);
return true;
}
if((scan == SDL_SCANCODE_RETURN && (mod & KMOD_ALT)) || scan == config_get_int(CONFIG_KEY_FULLSCREEN)) {
video_set_fullscreen(!video_is_fullscreen());
return true;
}
if(scan == config_get_int(CONFIG_KEY_TOGGLE_AUDIO)) {
config_set_int(CONFIG_MUTE_AUDIO, !config_get_int(CONFIG_MUTE_AUDIO));
return true;
}
if(scan == config_get_int(CONFIG_KEY_RELOAD_RESOURCES)) {
res_reload_all();
return true;
}
return false;
}