mkxp/src/eventthread.cpp

756 lines
15 KiB
C++

/*
** eventthread.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
**
** mkxp is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** mkxp is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "eventthread.h"
#include <SDL_events.h>
#include <SDL_joystick.h>
#include <SDL_messagebox.h>
#include <SDL_timer.h>
#include <SDL_thread.h>
#include <SDL_touch.h>
#include <SDL_rect.h>
#include <al.h>
#include <alext.h>
#include "sharedstate.h"
#include "graphics.h"
#include "settingsmenu.h"
#include "al-util.h"
#include "debugwriter.h"
#include <string.h>
typedef void (ALC_APIENTRY *LPALCDEVICEPAUSESOFT) (ALCdevice *device);
typedef void (ALC_APIENTRY *LPALCDEVICERESUMESOFT) (ALCdevice *device);
#define AL_DEVICE_PAUSE_FUN \
AL_FUN(DevicePause, LPALCDEVICEPAUSESOFT) \
AL_FUN(DeviceResume, LPALCDEVICERESUMESOFT)
struct ALCFunctions
{
#define AL_FUN(name, type) type name;
AL_DEVICE_PAUSE_FUN
#undef AL_FUN
} static alc;
static void
initALCFunctions(ALCdevice *alcDev)
{
if (!strstr(alcGetString(alcDev, ALC_EXTENSIONS), "ALC_SOFT_pause_device"))
return;
Debug() << "ALC_SOFT_pause_device present";
#define AL_FUN(name, type) alc. name = (type) alcGetProcAddress(alcDev, "alc" #name "SOFT");
AL_DEVICE_PAUSE_FUN;
#undef AL_FUN
}
#define HAVE_ALC_DEVICE_PAUSE alc.DevicePause
uint8_t EventThread::keyStates[];
EventThread::JoyState EventThread::joyState;
EventThread::MouseState EventThread::mouseState;
EventThread::TouchState EventThread::touchState;
/* User event codes */
enum
{
REQUEST_SETFULLSCREEN = 0,
REQUEST_WINRESIZE,
REQUEST_MESSAGEBOX,
REQUEST_SETCURSORVISIBLE,
UPDATE_FPS,
UPDATE_SCREEN_RECT,
EVENT_COUNT
};
static uint32_t usrIdStart;
bool EventThread::allocUserEvents()
{
usrIdStart = SDL_RegisterEvents(EVENT_COUNT);
if (usrIdStart == (uint32_t) -1)
return false;
return true;
}
EventThread::EventThread()
: fullscreen(false),
showCursor(false)
{}
void EventThread::process(RGSSThreadData &rtData)
{
SDL_Event event;
SDL_Window *win = rtData.window;
UnidirMessage<Vec2i> &windowSizeMsg = rtData.windowSizeMsg;
initALCFunctions(rtData.alcDev);
// XXX this function breaks input focus on OSX
#ifndef __MACOSX__
SDL_SetEventFilter(eventFilter, &rtData);
#endif
fullscreen = rtData.config.fullscreen;
int toggleFSMod = rtData.config.anyAltToggleFS ? KMOD_ALT : KMOD_LALT;
fps.lastFrame = SDL_GetPerformanceCounter();
fps.displayCounter = 0;
fps.acc = 0;
fps.accDiv = 0;
if (rtData.config.printFPS)
fps.sendUpdates.set();
bool displayingFPS = false;
bool cursorInWindow = false;
/* Will be updated eventually */
SDL_Rect gameScreen = { 0, 0, 0, 0 };
/* SDL doesn't send an initial FOCUS_GAINED event */
bool windowFocused = true;
bool terminate = false;
SDL_Joystick *js = 0;
if (SDL_NumJoysticks() > 0)
js = SDL_JoystickOpen(0);
char buffer[128];
char pendingTitle[128];
bool havePendingTitle = false;
bool resetting = false;
int winW, winH;
int i;
SDL_GetWindowSize(win, &winW, &winH);
SettingsMenu *sMenu = 0;
while (true)
{
if (!SDL_WaitEvent(&event))
{
Debug() << "EventThread: Event error";
break;
}
if (sMenu && sMenu->onEvent(event))
{
if (sMenu->destroyReq())
{
delete sMenu;
sMenu = 0;
updateCursorState(cursorInWindow && windowFocused, gameScreen);
}
continue;
}
/* Preselect and discard unwanted events here */
switch (event.type)
{
case SDL_MOUSEBUTTONDOWN :
case SDL_MOUSEBUTTONUP :
case SDL_MOUSEMOTION :
if (event.button.which == SDL_TOUCH_MOUSEID)
continue;
break;
case SDL_FINGERDOWN :
case SDL_FINGERUP :
case SDL_FINGERMOTION :
if (event.tfinger.fingerId >= MAX_FINGERS)
continue;
break;
}
/* Now process the rest */
switch (event.type)
{
case SDL_WINDOWEVENT :
switch (event.window.event)
{
case SDL_WINDOWEVENT_SIZE_CHANGED :
winW = event.window.data1;
winH = event.window.data2;
windowSizeMsg.post(Vec2i(winW, winH));
resetInputStates();
break;
case SDL_WINDOWEVENT_ENTER :
cursorInWindow = true;
mouseState.inWindow = true;
updateCursorState(cursorInWindow && windowFocused && !sMenu, gameScreen);
break;
case SDL_WINDOWEVENT_LEAVE :
cursorInWindow = false;
mouseState.inWindow = false;
updateCursorState(cursorInWindow && windowFocused && !sMenu, gameScreen);
break;
case SDL_WINDOWEVENT_CLOSE :
terminate = true;
break;
case SDL_WINDOWEVENT_FOCUS_GAINED :
windowFocused = true;
updateCursorState(cursorInWindow && windowFocused && !sMenu, gameScreen);
break;
case SDL_WINDOWEVENT_FOCUS_LOST :
windowFocused = false;
updateCursorState(cursorInWindow && windowFocused && !sMenu, gameScreen);
resetInputStates();
break;
}
break;
case SDL_QUIT :
terminate = true;
Debug() << "EventThread termination requested";
break;
case SDL_KEYDOWN :
if (event.key.keysym.scancode == SDL_SCANCODE_RETURN &&
(event.key.keysym.mod & toggleFSMod))
{
setFullscreen(win, !fullscreen);
if (!fullscreen && havePendingTitle)
{
SDL_SetWindowTitle(win, pendingTitle);
pendingTitle[0] = '\0';
havePendingTitle = false;
}
break;
}
if (event.key.keysym.scancode == SDL_SCANCODE_F1)
{
if (!sMenu)
{
sMenu = new SettingsMenu(rtData);
updateCursorState(false, gameScreen);
}
sMenu->raise();
}
if (event.key.keysym.scancode == SDL_SCANCODE_F2)
{
if (!displayingFPS)
{
fps.immInitFlag.set();
fps.sendUpdates.set();
displayingFPS = true;
}
else
{
displayingFPS = false;
if (!rtData.config.printFPS)
fps.sendUpdates.clear();
if (fullscreen)
{
/* Prevent fullscreen flicker */
strncpy(pendingTitle, rtData.config.windowTitle.c_str(),
sizeof(pendingTitle));
havePendingTitle = true;
break;
}
SDL_SetWindowTitle(win, rtData.config.windowTitle.c_str());
}
break;
}
if (event.key.keysym.scancode == SDL_SCANCODE_F12)
{
if (!rtData.config.enableReset)
break;
if (resetting)
break;
resetting = true;
rtData.rqResetFinish.clear();
rtData.rqReset.set();
break;
}
keyStates[event.key.keysym.scancode] = true;
break;
case SDL_KEYUP :
if (event.key.keysym.scancode == SDL_SCANCODE_F12)
{
if (!rtData.config.enableReset)
break;
resetting = false;
rtData.rqResetFinish.set();
break;
}
keyStates[event.key.keysym.scancode] = false;
break;
case SDL_JOYBUTTONDOWN :
joyState.buttons[event.jbutton.button] = true;
break;
case SDL_JOYBUTTONUP :
joyState.buttons[event.jbutton.button] = false;
break;
case SDL_JOYHATMOTION :
joyState.hats[event.jhat.hat] = event.jhat.value;
break;
case SDL_JOYAXISMOTION :
joyState.axes[event.jaxis.axis] = event.jaxis.value;
break;
case SDL_JOYDEVICEADDED :
if (event.jdevice.which > 0)
break;
js = SDL_JoystickOpen(0);
break;
case SDL_JOYDEVICEREMOVED :
resetInputStates();
break;
case SDL_MOUSEBUTTONDOWN :
mouseState.buttons[event.button.button] = true;
break;
case SDL_MOUSEBUTTONUP :
mouseState.buttons[event.button.button] = false;
break;
case SDL_MOUSEMOTION :
mouseState.x = event.motion.x;
mouseState.y = event.motion.y;
updateCursorState(cursorInWindow, gameScreen);
break;
case SDL_FINGERDOWN :
i = event.tfinger.fingerId;
touchState.fingers[i].down = true;
case SDL_FINGERMOTION :
i = event.tfinger.fingerId;
touchState.fingers[i].x = event.tfinger.x * winW;
touchState.fingers[i].y = event.tfinger.y * winH;
break;
case SDL_FINGERUP :
i = event.tfinger.fingerId;
memset(&touchState.fingers[i], 0, sizeof(touchState.fingers[0]));
break;
default :
/* Handle user events */
switch(event.type - usrIdStart)
{
case REQUEST_SETFULLSCREEN :
setFullscreen(win, static_cast<bool>(event.user.code));
break;
case REQUEST_WINRESIZE :
SDL_SetWindowSize(win, event.window.data1, event.window.data2);
break;
case REQUEST_MESSAGEBOX :
SDL_ShowSimpleMessageBox(event.user.code,
rtData.config.windowTitle.c_str(),
(const char*) event.user.data1, win);
free(event.user.data1);
msgBoxDone.set();
break;
case REQUEST_SETCURSORVISIBLE :
showCursor = event.user.code;
updateCursorState(cursorInWindow, gameScreen);
break;
case UPDATE_FPS :
if (rtData.config.printFPS)
Debug() << "FPS:" << event.user.code;
if (!fps.sendUpdates)
break;
snprintf(buffer, sizeof(buffer), "%s - %d FPS",
rtData.config.windowTitle.c_str(), event.user.code);
/* Updating the window title in fullscreen
* mode seems to cause flickering */
if (fullscreen)
{
strncpy(pendingTitle, buffer, sizeof(pendingTitle));
havePendingTitle = true;
break;
}
SDL_SetWindowTitle(win, buffer);
break;
case UPDATE_SCREEN_RECT :
gameScreen.x = event.user.windowID;
gameScreen.y = event.user.code;
gameScreen.w = reinterpret_cast<intptr_t>(event.user.data1);
gameScreen.h = reinterpret_cast<intptr_t>(event.user.data2);
updateCursorState(cursorInWindow, gameScreen);
break;
}
}
if (terminate)
break;
}
/* Just in case */
rtData.syncPoint.resumeThreads();
if (SDL_JoystickGetAttached(js))
SDL_JoystickClose(js);
delete sMenu;
}
int EventThread::eventFilter(void *data, SDL_Event *event)
{
RGSSThreadData &rtData = *static_cast<RGSSThreadData*>(data);
switch (event->type)
{
case SDL_APP_WILLENTERBACKGROUND :
Debug() << "SDL_APP_WILLENTERBACKGROUND";
if (HAVE_ALC_DEVICE_PAUSE)
alc.DevicePause(rtData.alcDev);
rtData.syncPoint.haltThreads();
return 0;
case SDL_APP_DIDENTERBACKGROUND :
Debug() << "SDL_APP_DIDENTERBACKGROUND";
return 0;
case SDL_APP_WILLENTERFOREGROUND :
Debug() << "SDL_APP_WILLENTERFOREGROUND";
return 0;
case SDL_APP_DIDENTERFOREGROUND :
Debug() << "SDL_APP_DIDENTERFOREGROUND";
if (HAVE_ALC_DEVICE_PAUSE)
alc.DeviceResume(rtData.alcDev);
rtData.syncPoint.resumeThreads();
return 0;
case SDL_APP_TERMINATING :
Debug() << "SDL_APP_TERMINATING";
return 0;
case SDL_APP_LOWMEMORY :
Debug() << "SDL_APP_LOWMEMORY";
return 0;
// case SDL_RENDER_TARGETS_RESET :
// Debug() << "****** SDL_RENDER_TARGETS_RESET";
// return 0;
// case SDL_RENDER_DEVICE_RESET :
// Debug() << "****** SDL_RENDER_DEVICE_RESET";
// return 0;
}
return 1;
}
void EventThread::cleanup()
{
SDL_Event event;
while (SDL_PollEvent(&event))
if ((event.type - usrIdStart) == REQUEST_MESSAGEBOX)
free(event.user.data1);
}
void EventThread::resetInputStates()
{
memset(&keyStates, 0, sizeof(keyStates));
memset(&joyState, 0, sizeof(joyState));
memset(&mouseState.buttons, 0, sizeof(mouseState.buttons));
memset(&touchState, 0, sizeof(touchState));
}
void EventThread::setFullscreen(SDL_Window *win, bool mode)
{
SDL_SetWindowFullscreen
(win, mode ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
fullscreen = mode;
}
void EventThread::updateCursorState(bool inWindow,
const SDL_Rect &screen)
{
SDL_Point pos = { mouseState.x, mouseState.y };
bool inScreen = inWindow && SDL_PointInRect(&pos, &screen);
if (inScreen)
SDL_ShowCursor(showCursor ? SDL_TRUE : SDL_FALSE);
else
SDL_ShowCursor(SDL_TRUE);
}
void EventThread::requestTerminate()
{
SDL_Event event;
event.type = SDL_QUIT;
SDL_PushEvent(&event);
}
void EventThread::requestFullscreenMode(bool mode)
{
if (mode == fullscreen)
return;
SDL_Event event;
event.type = usrIdStart + REQUEST_SETFULLSCREEN;
event.user.code = static_cast<Sint32>(mode);
SDL_PushEvent(&event);
}
void EventThread::requestWindowResize(int width, int height)
{
SDL_Event event;
event.type = usrIdStart + REQUEST_WINRESIZE;
event.window.data1 = width;
event.window.data2 = height;
SDL_PushEvent(&event);
}
void EventThread::requestShowCursor(bool mode)
{
SDL_Event event;
event.type = usrIdStart + REQUEST_SETCURSORVISIBLE;
event.user.code = mode;
SDL_PushEvent(&event);
}
void EventThread::showMessageBox(const char *body, int flags)
{
msgBoxDone.clear();
SDL_Event event;
event.user.code = flags;
event.user.data1 = strdup(body);
event.type = usrIdStart + REQUEST_MESSAGEBOX;
SDL_PushEvent(&event);
/* Keep repainting screen while box is open */
shState->graphics().repaintWait(msgBoxDone);
/* Prevent endless loops */
resetInputStates();
}
bool EventThread::getFullscreen() const
{
return fullscreen;
}
bool EventThread::getShowCursor() const
{
return showCursor;
}
void EventThread::notifyFrame()
{
if (!fps.sendUpdates)
return;
uint64_t current = SDL_GetPerformanceCounter();
uint64_t diff = current - fps.lastFrame;
fps.lastFrame = current;
if (fps.immInitFlag)
{
fps.immInitFlag.clear();
fps.immFiniFlag.set();
return;
}
static uint64_t freq = SDL_GetPerformanceFrequency();
double currFPS = (double) freq / diff;
fps.acc += currFPS;
++fps.accDiv;
fps.displayCounter += diff;
if (fps.displayCounter < freq && !fps.immFiniFlag)
return;
fps.displayCounter = 0;
fps.immFiniFlag.clear();
int32_t avgFPS = fps.acc / fps.accDiv;
fps.acc = fps.accDiv = 0;
SDL_Event event;
event.user.code = avgFPS;
event.user.type = usrIdStart + UPDATE_FPS;
SDL_PushEvent(&event);
}
void EventThread::notifyGameScreenChange(const SDL_Rect &screen)
{
/* We have to get a bit hacky here to fit the rectangle
* data into the user event struct */
SDL_Event event;
event.type = usrIdStart + UPDATE_SCREEN_RECT;
event.user.windowID = screen.x;
event.user.code = screen.y;
event.user.data1 = reinterpret_cast<void*>(screen.w);
event.user.data2 = reinterpret_cast<void*>(screen.h);
SDL_PushEvent(&event);
}
void SyncPoint::haltThreads()
{
if (mainSync.locked)
return;
/* Lock the reply sync first to avoid races */
reply.lock();
/* Lock main sync and sleep until RGSS thread
* reports back */
mainSync.lock();
reply.waitForUnlock();
/* Now that the RGSS thread is asleep, we can
* safely put the other threads to sleep as well
* without causing deadlocks */
secondSync.lock();
}
void SyncPoint::resumeThreads()
{
if (!mainSync.locked)
return;
mainSync.unlock(false);
secondSync.unlock(true);
}
bool SyncPoint::mainSyncLocked()
{
return mainSync.locked;
}
void SyncPoint::waitMainSync()
{
reply.unlock(false);
mainSync.waitForUnlock();
}
void SyncPoint::passSecondarySync()
{
if (!secondSync.locked)
return;
secondSync.waitForUnlock();
}
SyncPoint::Util::Util()
{
mut = SDL_CreateMutex();
cond = SDL_CreateCond();
}
SyncPoint::Util::~Util()
{
SDL_DestroyCond(cond);
SDL_DestroyMutex(mut);
}
void SyncPoint::Util::lock()
{
locked.set();
}
void SyncPoint::Util::unlock(bool multi)
{
locked.clear();
if (multi)
SDL_CondBroadcast(cond);
else
SDL_CondSignal(cond);
}
void SyncPoint::Util::waitForUnlock()
{
SDL_LockMutex(mut);
while (locked)
SDL_CondWait(cond, mut);
SDL_UnlockMutex(mut);
}