void SkOSWindow::RunEventLoop() {
for (;;) {
SkEvent::ServiceQueueTimer();
bool hasMoreSkEvents = SkEvent::ProcessEvent();
SDL_Event event;
bool hasSDLEvents = SDL_PollEvent(&event) == 1;
// Invalidations do not post to event loop, rather we just go through the
// windows for each event loop iteration.
bool hasDirtyWindows = HasDirtyWindows();
if (!hasSDLEvents && !hasMoreSkEvents && !hasDirtyWindows) {
// If there is no SDL events, SkOSWindow updates or SkEvents
// to be done, wait for the SDL events.
if (gTimerDelay > 0) {
hasSDLEvents = SDL_WaitEventTimeout(&event, gTimerDelay) == 1;
} else {
hasSDLEvents = SDL_WaitEvent(&event) == 1;
}
}
while (hasSDLEvents) {
if (event.type == SDL_QUIT) {
return;
}
HandleEvent(event);
hasSDLEvents = SDL_PollEvent(&event);
}
UpdateDirtyWindows();
}
}
void Platform::process_events() {
event_thread_running_ = true;
while (event_thread_running_) {
SDL_Event event;
while (SDL_WaitEventTimeout(&event, 100)) {
switch (event.type) {
case SDL_QUIT:
break;
case SDL_WINDOWEVENT:
for (auto &iter : windows_) {
if (auto w = iter.second.lock()) {
if (w->window_id() == event.window.windowID) {
w->process_event(event);
break;
}
}
}
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
case SDL_KEYDOWN:
case SDL_KEYUP:
process_input_event(event);
break;
default:
break;
}
}
}
}
int OnExecute()
{
if (OnInit() == false)
{
return -1;
}
SDL_Event Event;
while(Running)
{
if (g_engine)
{
for (int x = 0; x < 5 && SDL_WaitEventTimeout(&Event, 10); ++x)
{
if(!g_engine->IsPaused())
OnEvent(&Event);
}
if(!g_engine->IsPaused())
OnUpdate();
}
}
OnCleanup();
return 0;
};
bool
GHOST_SystemSDL::processEvents(bool waitForEvent)
{
// Get all the current events -- translate them into
// ghost events and call base class pushEvent() method.
bool anyProcessed = false;
do {
GHOST_TimerManager *timerMgr = getTimerManager();
if (waitForEvent && m_dirty_windows.empty() && !SDL_HasEvents(SDL_FIRSTEVENT, SDL_LASTEVENT)) {
GHOST_TUns64 next = timerMgr->nextFireTime();
if (next == GHOST_kFireTimeNever) {
SDL_WaitEventTimeout(NULL, -1);
//SleepTillEvent(m_display, -1);
}
else {
GHOST_TInt64 maxSleep = next - getMilliSeconds();
if (maxSleep >= 0) {
SDL_WaitEventTimeout(NULL, next - getMilliSeconds());
// SleepTillEvent(m_display, next - getMilliSeconds()); // X11
}
}
}
if (timerMgr->fireTimers(getMilliSeconds())) {
anyProcessed = true;
}
SDL_Event sdl_event;
while (SDL_PollEvent(&sdl_event)) {
processEvent(&sdl_event);
anyProcessed = true;
}
if (generateWindowExposeEvents()) {
anyProcessed = true;
}
} while (waitForEvent && !anyProcessed);
return anyProcessed;
}
int classic_game(void) {
srand((unsigned int)time(NULL));
Uint8 r=((rand()%128)+128);
Uint8 g=((rand()%128)+128);
Uint8 b=((rand()%128)+128);
Game_Snake S;
int d=-1;
SDL_Event e;
Uint32 ticks;
while(1) {
ticks=SDL_GetTicks();
SDL_RenderClear(gRenderer);
SDL_SetRenderDrawColor(gRenderer, r, g, b, 0xFF);
while(SDL_WaitEventTimeout(&e, 4)) {
if(e.type==SDL_QUIT) {
exit(0);
}
else if(e.type==SDL_KEYDOWN && e.key.repeat==0) {
switch(e.key.keysym.sym) {
case SDLK_ESCAPE:
SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
show_gameover(S.getscore());
return S.getscore();
case SDLK_UP:
d=UP;
break;
case SDLK_DOWN:
d=DOWN;
break;
case SDLK_RIGHT:
d=RIGHT;
break;
case SDLK_LEFT:
d=LEFT;
break;
}
if(diff(S.getfdir(), d)!=2 && d!=S.getfdir()) {
S.createnode(d);
}
}
}
S.movesnake();
S.render();
if(S.getcoll()) {
SDL_Delay(TIMEOUT_LONG);
SDL_RenderClear(gRenderer);
SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
wait();
show_gameover(S.getscore());
return S.getscore();
}
SDL_RenderPresent(gRenderer);
while(SDL_GetTicks()-ticks<16) {
SDL_Delay(1);
}
}
}
static mrb_value
mrb_sdl2_input_wait_timeout(mrb_state *mrb, mrb_value mod)
{
mrb_int timeout;
mrb_get_args(mrb, "i", &timeout);
SDL_Event event;
if (0 == SDL_WaitEventTimeout(&event, timeout)) {
return mrb_nil_value();
}
return mrb_sdl2_input_event(mrb, &event);
}
bool backend_should_display_next_frame(int64_t time_remaining_this_frame)
{
if(time_remaining_this_frame > 0) {
SDL_Event event;
if(SDL_WaitEventTimeout(&event, time_remaining_this_frame) != 0) {
switch(event.type) {
case SDL_KEYUP:
return false;
break;
}
}
}
return true;
}
int flubPollEvent(SDL_Event *event, Uint32 *ticks, Uint32 *elapsed, Uint32 *wait) {
Uint32 currentTicks;
Uint32 elapsedTicks;
int result;
int timeout;
currentTicks = SDL_GetTicks();
if(_coreCtx.lastTick == 0) {
elapsedTicks = 0;
} else {
elapsedTicks = currentTicks - _coreCtx.lastTick;
}
_coreCtx.lastTick = currentTicks;
_coreCtx.elapsed = elapsedTicks;
if(ticks != NULL) {
*ticks = currentTicks;
}
if(elapsed != NULL) {
*elapsed = elapsedTicks;
}
if(wait != NULL) {
*wait -= currentTicks;
if(*wait <= 0) {
*wait = 0;
} else {
timeout = *wait;
}
} else {
timeout = 0;
}
while(1) {
if(!SDL_WaitEventTimeout(event, timeout)) {
return 0;
}
// TODO Pre-filter event, before passing on to caller
return 1;
}
}
/*
* SDL.waitEvent(timeout)
*
* Arguments:
* timeout (optional) the timeout
*
* Returns:
* The event or nil on failure
* The error message
*/
static int
l_event_waitEvent(lua_State *L)
{
SDL_Event ev;
int timeout, ret;
if (lua_gettop(L) >= 1) {
timeout = luaL_checkinteger(L, 1);
ret = SDL_WaitEventTimeout(&ev, timeout);
} else {
ret = SDL_WaitEvent(&ev);
}
if (!ret)
return commonPushSDLError(L, 1);
eventPush(L, &ev);
return 1;
}
int
SDL_PollEvent(SDL_Event * event)
{
return SDL_WaitEventTimeout(event, 0);
}
int main(int argc, char *argv[])
{
coordinates coord; // Coodinates Structure
depth depth;
color colorsIn[2048]; // Colors array
int numColors = 0; // Number of colors to use in color array
float colorPower = .3; // Power exponent to use for color selection
int colorStart = 0xFF0000, colorEnd = 0xFFFF00; // Default color gradient settings
char *filename = "mandelbrot.png"; // Default PNG output name
int i; // Misc variables
bool noWindow = false; // Default flag for no-window mode
// Set default coordinates before reading in args
coord.x = -2; // Default Start Coordinates
coord.y = 2;
coord.xR = 4; // Default Range Coordinates
coord.yR = 4;
coord.width = -1; // Invalid pixel size, to be set later
coord.height = -1;
depth.d = 100; // Default Depth level of Mandelbrot Calculation
depth.automatic = true;
// Generate default gradient first
genGradient(colorsIn, &numColors, colorStart, colorEnd);
// Parse Arguments
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "--width") == 0)
{
coord.width = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--height") == 0)
{
coord.height = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--depth") == 0)
{
depth.automatic = false;
depth.d = arg_check_int(argc, argv, i, 1, 10);
i++;
}
else if (strcmp(argv[i], "--coords") == 0)
{
coord.x = arg_check_float(argc, argv, i, 1);
coord.y = arg_check_float(argc, argv, i, 2);
coord.xR = arg_check_float(argc, argv, i, 3);
coord.yR = arg_check_float(argc, argv, i, 4);
i+=4;
}
else if (strcmp(argv[i], "--spectrum") == 0)
{
genSpectrum(colorsIn, &numColors);
colorPower = .7;
}
else if (strcmp(argv[i], "--random") == 0)
{
genRandom(colorsIn, &numColors);
colorPower = 1;
}
else if (strcmp(argv[i], "--gradient") == 0)
{
colorStart = arg_check_int(argc, argv, i, 1, 16);
colorEnd = arg_check_int(argc, argv, i, 2, 16);
genGradient(colorsIn, &numColors, colorStart, colorEnd);
i+=2;
}
else if (strcmp(argv[i], "-o") == 0)
{
filename = argv[i+1];
i++;
}
else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 )
{
help();
}
else if (strcmp(argv[i], "-nw") == 0 )
{
noWindow = true;
}
else
{
errx(EXIT_FAILURE, "Unknown argument, \"%s\".", argv[i]);
}
}
// Make proportional image if only one dimension is specified
// Set to default width and height if not specified
if (coord.height < 0 && coord.width > 0) coord.height = coord.width / coord.xR * coord.yR;
else if (coord.height > 0 && coord.width < 0) coord.width = coord.height / coord.yR * coord.xR;
else if (coord.height < 0 && coord.width < 0) coord.width = coord.height = 1024;
coord.xS = coord.xR/coord.width; // X Step Value
coord.yS = coord.yR/coord.height; // Y Step Value
// Create final array of colors to use that is scaled to the depth that is selected
color colors[2048];
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
// If no window mode, just output file and exit
if (noWindow)
{
generate_png(coord, depth.d, filename, colors, numColors);
return 0;
}
// Set up SDL
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* Main_Window;
SDL_Renderer* Main_Renderer;
Main_Window = SDL_CreateWindow("Mandelbrot", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, coord.width, coord.height, SDL_WINDOW_RESIZABLE);
Main_Renderer = SDL_CreateRenderer(Main_Window, -1, SDL_RENDERER_ACCELERATED);
SDL_Texture *texture = SDL_CreateTexture(Main_Renderer, SDL_PIXELFORMAT_RGBX8888, SDL_TEXTUREACCESS_STREAMING, coord.width, coord.height);
int pitch;
void *pixels;
if (SDL_LockTexture(texture, NULL, &pixels, &pitch) != 0)
errx(EXIT_FAILURE, "SDL_LockTexture: %s", SDL_GetError());
//uint32_t (*pixel)[coord.height][pitch/sizeof(uint32_t)] = pixels;
// Set up struct for tracking mouse movement
mouse mouseTracker;
mouseTracker.down = false;
//Main Loop
int maxRender = 2;
int needsRender = maxRender;
while (1)
{
// Render Loop
if (needsRender > 0)
{
uint32_t (*pixel)[coord.height][pitch/sizeof(uint32_t)] = pixels;
//unsigned long long timer = utime(); //DEBUG - Start Timer
float pixelSize = pow(2, --needsRender);
//printf("%d %d\n", needsRender, pixelSize);
coordinates scaledCoord;
scaledCoord.width = coord.width / pixelSize;
scaledCoord.height = coord.height / pixelSize;
scaledCoord.x = coord.x;
scaledCoord.xR = coord.xR;
scaledCoord.xS = scaledCoord.xR/scaledCoord.width;
scaledCoord.y = coord.y;
scaledCoord.yR = coord.yR;
scaledCoord.yS = scaledCoord.yR/scaledCoord.height; // y step value
SDL_Rect srcrect = {0, 0, scaledCoord.width, scaledCoord.height};
for (int y=0; y<scaledCoord.height; y++)
for (int x=0; x<scaledCoord.width; x++)
{
double xValue = scaledCoord.x + (x * scaledCoord.xS);
double yValue = scaledCoord.y - (y * scaledCoord.yS);
int result = mandel(xValue, yValue, depth.d);
int finalColor = 0;
if (result != -1)
finalColor = colors[result].hex << 8;
(*pixel)[y][x] = finalColor;
}
SDL_UnlockTexture(texture);
SDL_RenderCopy(Main_Renderer, texture, &srcrect, NULL);
//printf("%llu - Finish Render\n", utime()-timer); //DEBUG - End Timer
SDL_RenderPresent(Main_Renderer);
}
SDL_Event e;
//SDL_WaitEvent(&e);
if (SDL_WaitEventTimeout(&e, 10) == 0) continue;
if (e.type == SDL_MOUSEWHEEL)
{
if (e.wheel.y > 0)
coord_zoom(&coord, 1);
else
coord_zoom(&coord, -1);
if (depth.automatic == true)
{
adjust_depth(&coord, &depth);
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
}
needsRender = maxRender;
}
if (e.type == SDL_WINDOWEVENT)
if (e.window.event == SDL_WINDOWEVENT_RESIZED)
{
// Adjust view to new size
coord.width = e.window.data1;
coord.height = e.window.data2;
coord.xR = coord.width * coord.xS;
coord.yR = coord.height * coord.yS;
// Destroy old texture
SDL_DestroyTexture(texture);
// Make New Texture
texture = SDL_CreateTexture(Main_Renderer, SDL_PIXELFORMAT_RGBX8888, SDL_TEXTUREACCESS_STREAMING, coord.width, coord.height);
// Lock with new texture
if (SDL_LockTexture(texture, NULL, &pixels, &pitch) != 0)
errx(EXIT_FAILURE, "SDL_LockTexture: %s", SDL_GetError());
// Rerender
needsRender = maxRender;
}
if (e.type == SDL_MOUSEBUTTONDOWN)
if (e.button.state == SDL_PRESSED)
{
mouseTracker.mouseX = e.motion.x;
mouseTracker.mouseY = e.motion.y;
mouseTracker.coordX = coord.x;
mouseTracker.coordY = coord.y;
mouseTracker.down = true;
}
if (e.type == SDL_MOUSEBUTTONUP)
if (e.button.state == SDL_RELEASED)
mouseTracker.down = false;
if (e.type == SDL_MOUSEMOTION && mouseTracker.down == true)
{
coord.x = mouseTracker.coordX + ((mouseTracker.mouseX - e.motion.x) * coord.xS);
coord.y = mouseTracker.coordY - ((mouseTracker.mouseY - e.motion.y) * coord.yS);
needsRender = maxRender;
}
if (e.type == SDL_KEYUP)
{
if (e.key.keysym.sym == SDLK_p)
print_coords(&coord, &depth);
if (e.key.keysym.sym == SDLK_s)
generate_png(coord, depth.d, filename, colors, numColors);
if (e.key.keysym.sym == SDLK_EQUALS || e.key.keysym.sym == SDLK_MINUS)
{
depth.automatic = false;
if (e.key.keysym.sym == SDLK_EQUALS)
depth.d += 5;
if (e.key.keysym.sym == SDLK_MINUS)
if (depth.d > 5) depth.d -= 5;
scaleColor(colorsIn, colors, numColors, depth.d, colorPower);
needsRender = maxRender;
}
}
if (e.type == SDL_QUIT)
{
SDL_Log("Program quit after %i ticks", e.quit.timestamp);
break;
}
}
return 0;
}
int main (int argc, char *argv[])
#endif
{
int err = SDL_Init(SDL_INIT_EVERYTHING);
if (err != 0) {
printf("SDL_Init failed: %s\n", SDL_GetError());
return err;
}
WCLOCK_nxt = CEU_WCLOCK_INACTIVE;
u32 old = SDL_GetTicks();
#ifdef CEU_FPS
int fps_next = (1000/CEU_FPS);
#endif
tceu_app app;
app.data = (tceu_org*) &CEU_DATA;
app.init = &ceu_app_init;
#ifdef CEU_THREADS
// just before executing CEU code
CEU_THREADS_MUTEX_LOCK(&app.threads_mutex);
#endif
app.init(&app); /* calls CEU_THREADS_MUTEX_LOCK() */
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#ifndef SIMULATION_TEST
#ifdef CEU_IN_OS_START_
ceu_sys_go(&app, CEU_IN_OS_START_, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#endif
#ifdef CEU_IN_OS_START
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_OS_START, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
#ifdef CEU_IN_SDL_REDRAW_
ceu_sys_go(&app, CEU_IN_SDL_REDRAW_, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#endif
#ifdef CEU_IN_SDL_REDRAW
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_REDRAW, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
#endif /* SIMULATION_TEST */
SDL_Event evt;
#ifdef __ANDROID__
int isPaused = 0;
#endif
for (;;)
{
#ifdef CEU_THREADS
// unlock from INIT->START->REDRAW or last loop iteration
CEU_THREADS_MUTEX_UNLOCK(&app.threads_mutex);
#endif
/*
* With SDL_DT, 'tm=0' (update as fast as possible).
* Without SDL_DT, 'tm=?' respects the timers.
*/
#if defined(CEU_IN_SDL_DT) || defined(CEU_IN_SDL_DT_) || defined(CEU_FPS)
#ifdef CEU_FPS
s32 tm = (CEU_TIMEMACHINE_ON ? 0 : fps_next);
#else
s32 tm = 0; // as fast as possible
#endif
#else /* !(defined(CEU_IN_SDL_DT) || defined(CEU_IN_SDL_DT_) || defined(CEU_FPS)) */
s32 tm = -1;
#ifdef CEU_WCLOCKS
if (WCLOCK_nxt != CEU_WCLOCK_INACTIVE)
tm = WCLOCK_nxt / 1000;
#endif
#ifdef CEU_ASYNCS
if (app.pendingAsyncs) {
tm = 0;
}
#endif
#endif /* defined(CEU_IN_SDL_DT) || defined(CEU_IN_SDL_DT_) || defined(CEU_FPS) */
//SDL_EventState(SDL_FINGERMOTION, SDL_IGNORE);
int has;
#ifdef __ANDROID__
if (isPaused) {
has = SDL_WaitEvent(&evt);
} else
#endif
{
has = SDL_WaitEventTimeout(&evt, tm);
}
#ifndef SIMULATION_TEST
u32 now = SDL_GetTicks();
s32 dt_ms = (now - old);
assert(dt_ms >= 0);
old = now;
#ifdef CEU_FPS
/* force dt_ms=(1000/CEU_FPS) */
int fps_ok = 0;
int togo = (fps_next - dt_ms);
if (togo <= 0) {
fps_ok = 1;
dt_ms = (1000/CEU_FPS);
fps_next = (dt_ms + togo);
if (fps_next < 0) {
/*printf("[TODO: main.c] delayed %d\n", -fps_next);*/
fps_next = 0;
}
} else {
fps_next = togo;
}
assert(fps_next >= 0);
#else
int fps_ok = 1;
#endif
s32 dt_us = dt_ms*1000;
#ifdef CEU_THREADS
// just before executing CEU code
CEU_THREADS_MUTEX_LOCK(&app.threads_mutex);
#endif
#ifdef __ANDROID__
if (!isPaused)
#endif
if (fps_ok) {
#ifdef CEU_WCLOCKS
#if ! (defined(CEU_IN_SDL_DT) || defined(CEU_IN_SDL_DT_))
if (WCLOCK_nxt != CEU_WCLOCK_INACTIVE)
{
//redraw = WCLOCK_nxt <= dt_us;
#endif
#ifdef CEU_TIMEMACHINE
//#ifdef CEU_IN__WCLOCK_ (TODO: always defined)
ceu_sys_go(&app, CEU_IN__WCLOCK_, &dt_us);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
while (WCLOCK_nxt <= 0) {
s32 dt_us = 0;
ceu_sys_go(&app, CEU_IN__WCLOCK_, &dt_us);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN__WCLOCK, &dt_us);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
while (WCLOCK_nxt <= 0) {
s32 dt_us = 0;
ceu_sys_go(&app, CEU_IN__WCLOCK, &dt_us);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
}
#if ! (defined(CEU_IN_SDL_DT) || defined(CEU_IN_SDL_DT_))
}
#endif
#endif
#ifdef CEU_IN_SDL_DT_
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_DT_, &dt_ms);
}
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
//redraw = 1;
#endif
#ifdef CEU_IN_SDL_DT
if (!CEU_TIMEMACHINE_ON) {
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_DT, &dt_ms);
}
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
//redraw = 1;
}
#endif
}
// OTHER EVENTS
if (has)
{
int handled = 1; // =1 for defined events
SDL_Event* evtp = &evt;
switch (evt.type) {
case SDL_QUIT:
#ifdef CEU_IN_SDL_QUIT_
ceu_sys_go(&app, CEU_IN_SDL_QUIT_, &evtp);
#endif
#ifdef CEU_IN_SDL_QUIT
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_QUIT, &evtp);
}
#endif
break;
case SDL_WINDOWEVENT:
#ifdef CEU_IN_SDL_WINDOWEVENT_
ceu_sys_go(&app, CEU_IN_SDL_WINDOWEVENT_, &evtp);
#endif
#ifdef CEU_IN_SDL_WINDOWEVENT
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_WINDOWEVENT, &evtp);
}
#endif
break;
case SDL_KEYDOWN:
#ifdef CEU_IN_SDL_KEYDOWN_
ceu_sys_go(&app, CEU_IN_SDL_KEYDOWN_, &evtp);
#endif
#ifdef CEU_IN_SDL_KEYDOWN
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_KEYDOWN, &evtp);
}
#endif
break;
case SDL_KEYUP:
#ifdef CEU_IN_SDL_KEYUP_
ceu_sys_go(&app, CEU_IN_SDL_KEYUP_, &evtp);
#endif
#ifdef CEU_IN_SDL_KEYUP
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_KEYUP, &evtp);
}
#endif
break;
case SDL_TEXTINPUT:
#ifdef CEU_IN_SDL_TEXTINPUT_
ceu_sys_go(&app, CEU_IN_SDL_TEXTINPUT_, &evtp);
#endif
#ifdef CEU_IN_SDL_TEXTINPUT
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_TEXTINPUT, &evtp);
}
#endif
break;
case SDL_TEXTEDITING:
#ifdef CEU_IN_SDL_TEXTEDITING_
ceu_sys_go(&app, CEU_IN_SDL_TEXTEDITING_, &evtp);
#endif
#ifdef CEU_IN_SDL_TEXTEDITING
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_TEXTEDITING, &evtp);
}
#endif
break;
case SDL_MOUSEMOTION:
#ifdef CEU_IN_SDL_MOUSEMOTION_
ceu_sys_go(&app, CEU_IN_SDL_MOUSEMOTION_, &evtp);
#endif
#ifdef CEU_IN_SDL_MOUSEMOTION
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_MOUSEMOTION, &evtp);
}
#endif
break;
case SDL_MOUSEBUTTONDOWN:
#ifdef CEU_IN_SDL_MOUSEBUTTONDOWN_
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONDOWN_, &evtp);
#endif
#ifdef CEU_IN_SDL_MOUSEBUTTONDOWN
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONDOWN, &evtp);
}
#endif
break;
case SDL_MOUSEBUTTONUP:
#ifdef CEU_IN_SDL_MOUSEBUTTONUP_
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONUP_, &evtp);
#endif
#ifdef CEU_IN_SDL_MOUSEBUTTONUP
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONUP, &evtp);
}
#endif
break;
case SDL_FINGERDOWN:
#ifdef CEU_IN_SDL_FINGERDOWN_
ceu_sys_go(&app, CEU_IN_SDL_FINGERDOWN_, &evtp);
#endif
#ifdef CEU_IN_SDL_FINGERDOWN
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_FINGERDOWN, &evtp);
}
#endif
break;
case SDL_FINGERUP:
#ifdef CEU_IN_SDL_FINGERUP_
ceu_sys_go(&app, CEU_IN_SDL_FINGERUP_, &evtp);
#endif
#ifdef CEU_IN_SDL_FINGERUP
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_FINGERUP, &evtp);
}
#endif
break;
case SDL_FINGERMOTION:
#ifdef CEU_IN_SDL_FINGERMOTION_
ceu_sys_go(&app, CEU_IN_SDL_FINGERMOTION_, &evtp);
#endif
#ifdef CEU_IN_SDL_FINGERMOTION
if (!CEU_TIMEMACHINE_ON) {
ceu_sys_go(&app, CEU_IN_SDL_FINGERMOTION, &evtp);
}
#endif
break;
/* TODO: "_" events */
#if defined(CEU_IN_SDL_APP_WILLENTERBACKGROUND) || defined(__ANDROID__)
case SDL_APP_WILLENTERBACKGROUND:
#ifdef __ANDROID__
// handle onPause/onResume
isPaused = 1;
#endif
#ifdef CEU_IN_SDL_APP_WILLENTERBACKGROUND
ceu_sys_go(&app, CEU_IN_SDL_APP_WILLENTERBACKGROUND, &evtp);
#endif
break;
#endif
#if defined(CEU_IN_SDL_APP_WILLENTERFOREGROUND) || defined(__ANDROID__)
case SDL_APP_WILLENTERFOREGROUND:
#ifdef __ANDROID__
// handle onPause/onResume
isPaused = 0;
old = SDL_GetTicks(); // ignores previous 'old' on resume
#endif
#ifdef CEU_IN_SDL_APP_WILLENTERFOREGROUND
ceu_sys_go(&app, CEU_IN_SDL_APP_WILLENTERFOREGROUND, &evtp);
#endif
break;
#endif
default:
handled = 0; // undefined event
}
#ifdef CEU_RET
if (! app.isAlive) goto END;
#endif
//redraw = redraw || handled;
}
#ifdef CEU_IN_SDL_REDRAW_
//if (redraw && !SDL_PollEvent(NULL))
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_REDRAW_, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
#ifdef CEU_IN_SDL_REDRAW
if (!CEU_TIMEMACHINE_ON) {
//if (redraw && !SDL_PollEvent(NULL))
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_REDRAW, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
}
#endif
#endif /* SIMULATION_TEST */
/* TODO: "_" events */
#ifdef CEU_ASYNCS
if (app.pendingAsyncs) {
ceu_sys_go(&app, CEU_IN__ASYNC, NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
}
END:
#ifdef CEU_THREADS
// only reachable if LOCKED
CEU_THREADS_MUTEX_UNLOCK(&app.threads_mutex);
#endif
SDL_Quit(); // TODO: slow
#ifdef CEU_RET
return app.ret;
#else
return 0;
#endif
}
bool waitEvent(SDL_Event event, SDL_Window* window, int* selectedItem, Player* player, block** map, client_network out){ //Gére les différents évenement
bool quit = false;
int mouseX,mouseY;
//block air = {NONE, SKY};
//block cave = {NONE, CAVE};
//block dirt = {DIRT, SKY, true};
//block stone = {STONE, CAVE, true};
//block wood = {WOOD, CAVE};
//block iron = {IRON, CAVE, true};
if(SDL_WaitEventTimeout(&event, 50)){
switch (event.type) {
case SDL_WINDOWEVENT:
if(event.window.event == SDL_WINDOWEVENT_CLOSE){
quit = true;
printf("Close window\n");
}
break;
case SDL_MOUSEBUTTONUP:
if(event.button.button == SDL_BUTTON_LEFT){
SDL_GetMouseState(&mouseX,&mouseY);
putBlock(player, mouseX/24 + player->position[0] - NB_LIGNE/2, mouseY/24 + player->position[1] - NB_COLONNE/2, *selectedItem, map, out);
SDL_UpdateWindowSurface(window);
}
else if(event.button.button == SDL_BUTTON_RIGHT){
SDL_GetMouseState(&mouseX,&mouseY);
breakBlock(player, mouseX/24 + player->position[0] - NB_LIGNE/2, mouseY/24 + player->position[1] - NB_COLONNE/2, map, out);
SDL_UpdateWindowSurface(window);
}
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym){
case SDLK_ESCAPE:
quit = true;
printf("Close window\n");
break;
case SDLK_LEFT:
move(player, LEFT, map, out);
break;
case SDLK_RIGHT:
move(player, RIGHT, map, out);
break;
case SDLK_UP:
move(player, TOP, map, out);
break;
/*case SDLK_DOWN:
move(player, BOT, map, out);
break;*/
case '&':
*selectedItem = 0;
break;
case 233:
*selectedItem = 1;
break;
case '"':
*selectedItem = 2;
break;
case '\'':
*selectedItem = 3;
break;
}
break;
case SDL_MOUSEWHEEL :
if(event.wheel.y == -1){
*selectedItem = (*selectedItem + 1) % 4;
}
else if (event.wheel.y == 1){
*selectedItem = (*selectedItem - 1) ;
if(*selectedItem < 0){
*selectedItem = 3;
}
}
SDL_UpdateWindowSurface(window);
break;
}
}
return quit;
}
int main (int argc, char *argv[])
#endif
{
int ret;
SDL_Init(SDL_INIT_EVERYTHING);
#ifdef IN_SDL_DT
WCLOCK_nxt = 20000;
#else
WCLOCK_nxt = CEU_WCLOCK_NONE;
#endif
#if defined(CEU_WCLOCKS) || defined(CEU_ASYNCS)
u32 old = SDL_GetTicks();
#endif
if (ceu_go_init(&ret))
goto END;
#ifdef IN_START
if (ceu_go_event(&ret, IN_START, NULL))
goto END;
#endif
SDL_Event evt;
for (;;)
{
#ifndef SDL_SIMUL
s32 tm = -1;
#ifdef CEU_WCLOCKS
if (WCLOCK_nxt != CEU_WCLOCK_NONE)
tm = WCLOCK_nxt / 1000;
#endif
#ifdef CEU_ASYNCS
if (ASYNC_nxt)
tm = 0;
#endif
int has = SDL_WaitEventTimeout(&evt, tm);
//printf("...\n");
#if defined(CEU_WCLOCKS) || defined(CEU_ASYNCS)
u32 now = SDL_GetTicks();
#endif
// OTHER EVENTS
if (has)
{
int s = 0;
//printf("EVT: %d\n", evt.type);
switch (evt.type) {
#ifdef IN_SDL_QUIT
case SDL_QUIT:
s = ceu_go_event(&ret, IN_SDL_QUIT, NULL);
break;
#endif
#ifdef IN_SDL_WINDOWEVENT
case SDL_WINDOWEVENT:
s = ceu_go_event(&ret, IN_SDL_WINDOWEVENT, &evt);
break;
#endif
#ifdef IN_SDL_KEYDOWN
case SDL_KEYDOWN:
s = ceu_go_event(&ret, IN_SDL_KEYDOWN, &evt);
break;
#endif
#ifdef IN_SDL_KEYUP
case SDL_KEYUP:
s = ceu_go_event(&ret, IN_SDL_KEYUP, &evt);
break;
#endif
#ifdef IN_SDL_TEXTINPUT
case SDL_TEXTINPUT:
s = ceu_go_event(&ret, IN_SDL_TEXTINPUT, &evt);
break;
#endif
#ifdef IN_SDL_TEXTEDITING
case SDL_TEXTEDITING:
s = ceu_go_event(&ret, IN_SDL_TEXTEDITING, &evt);
break;
#endif
#ifdef IN_SDL_MOUSEMOTION
case SDL_MOUSEMOTION:
s = ceu_go_event(&ret, IN_SDL_MOUSEMOTION, &evt);
break;
#endif
#ifdef IN_SDL_MOUSEBUTTONDOWN
case SDL_MOUSEBUTTONDOWN:
s = ceu_go_event(&ret, IN_SDL_MOUSEBUTTONDOWN, &evt);
break;
#endif
#ifdef IN_SDL_MOUSEBUTTONUP
case SDL_MOUSEBUTTONUP:
s = ceu_go_event(&ret, IN_SDL_MOUSEBUTTONUP, &evt);
break;
#endif
}
if (s) goto END;
}
#if defined(CEU_WCLOCKS) || defined(CEU_ASYNCS)
s32 dt = now - old;
old = now;
#endif
#ifdef CEU_WCLOCKS
if (WCLOCK_nxt != CEU_WCLOCK_NONE) {
s32 nxt;
int s = ceu_go_wclock(&ret, 1000*dt, &nxt);
if (s) goto END;
while (nxt <= 0) {
s = ceu_go_wclock(&ret, 0, &nxt);
if (s) goto END;
}
}
#endif
#ifdef IN_SDL_DT
if (ceu_go_event(&ret, IN_SDL_DT, &dt))
goto END;
#endif
#ifdef IN_SDL_REDRAW
if (ceu_go_event(&ret, IN_SDL_REDRAW, NULL))
goto END;
#endif
#endif // SDL_SIMUL
#ifdef CEU_ASYNCS
if (ASYNC_nxt) {
if (ceu_go_async(&ret, NULL))
goto END;
}
#endif
}
END:
SDL_Quit(); // TODO: slow
return ret;
}
/*-----------------------------------------------------------------
* Desc: should do roughly what getchar() does, but in raw
* (SLD) keyboard mode.
*
* Return: the (SDLKey) of the next key-pressed event cast to (int)
*
*-----------------------------------------------------------------*/
int
getchar_raw (void)
{
SDL_Event event;
int Returnkey = 0;
// keyboard_update (); /* treat all pending keyboard-events */
while ( !Returnkey )
{
while (!SDL_WaitEventTimeout (&event, 10)) /* wait for next event */
SDL_Flip (ne_screen);
switch (event.type)
{
case SDL_KEYDOWN:
/*
* here we use the fact that, I cite from SDL_keyboard.h:
* "The keyboard syms have been cleverly chosen to map to ASCII"
* ... I hope that this design feature is portable, and durable ;)
*/
Returnkey = (int) event.key.keysym.sym;
if ( event.key.keysym.mod & KMOD_SHIFT )
Returnkey = toupper( (int)event.key.keysym.sym );
break;
case SDL_JOYBUTTONDOWN:
#ifdef JOY_BUTTON_COUNT
if (event.jbutton.button < JOY_BUTTON_COUNT)
Returnkey = joy_button_map[event.jbutton.button];
#else
if (event.jbutton.button == 0)
Returnkey = JOY_BUTTON1;
else if (event.jbutton.button == 1)
Returnkey = JOY_BUTTON2;
else if (event.jbutton.button == 2)
Returnkey = JOY_BUTTON3;
#endif
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
Returnkey = MOUSE_BUTTON1;
else if (event.button.button == SDL_BUTTON_RIGHT)
Returnkey = MOUSE_BUTTON2;
else if (event.button.button == SDL_BUTTON_MIDDLE)
Returnkey = MOUSE_BUTTON3;
else if (event.button.button == SDL_BUTTON_WHEELUP)
Returnkey = MOUSE_WHEELUP;
else if (event.button.button == SDL_BUTTON_WHEELDOWN)
Returnkey = MOUSE_WHEELDOWN;
break;
default:
SDL_PushEvent (&event); /* put this event back into the queue */
update_input (); /* and treat it the usual way */
continue;
}
} /* while(1) */
return ( Returnkey );
} /* getchar_raw() */
int
SDL_WaitEvent(SDL_Event * event)
{
return SDL_WaitEventTimeout(event, -1);
}
int fs_ml_video_create_window(const char *title)
{
fs_log("fs_ml_video_create_window\n");
g_window_title = g_strdup(title);
g_fs_ml_keyboard_input_grab = fs_config_get_boolean(
"keyboard_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
g_fs_ml_keyboard_input_grab = 1;
}
fs_log("keyboard input grab: %d\n", g_fs_ml_keyboard_input_grab);
static int initialized = 0;
SDL_SetHint(SDL_HINT_GRAB_KEYBOARD,
g_fs_ml_keyboard_input_grab ? "1" : "0");
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
#ifdef WINDOWS
SDL_SetHint(SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4, "1");
#endif
SDL_Init(SDL_INIT_VIDEO);
SDL_version cversion, lversion;
SDL_VERSION(&cversion);
SDL_GetVersion(&lversion);
fs_log("[SDL] Version %d.%d.%d (Compiled against %d.%d.%d)\n",
lversion.major, lversion.minor, lversion.patch,
cversion.major, cversion.minor, cversion.patch);
if (!initialized) {
int display_index = 0;
SDL_DisplayMode mode;
int error = SDL_GetCurrentDisplayMode(display_index, &mode);
if (error) {
fs_log("SDL_GetCurrentDisplayMode failed\n");
SDL_ShowSimpleMessageBox(
SDL_MESSAGEBOX_ERROR, "Display Error",
"SDL_GetCurrentDisplayMode failed.", NULL);
exit(1);
}
fs_emu_monitor_init();
const char *mon = fs_config_get_const_string("monitor");
int mon_flag = -1;
if (mon == NULL) {
mon = "middle-left";
}
if (strcmp(mon, "left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_LEFT;
} else if (strcmp(mon, "middle-left") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
} else if (strcmp(mon, "middle-right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_RIGHT;
} else if (strcmp(mon, "right") == 0) {
mon_flag = FS_EMU_MONITOR_FLAG_RIGHT;
}
else {
mon_flag = FS_EMU_MONITOR_FLAG_MIDDLE_LEFT;
}
FSEmuMonitor monitor;
fs_emu_monitor_get_by_flag(mon_flag, &monitor);
fs_log("Monitor \"%s\" (flag %d) => index %d\n",
mon, mon_flag, monitor.index);
g_display = monitor.index;
g_fullscreen_width = fs_config_get_int("fullscreen_width");
if (g_fullscreen_width == FS_CONFIG_NONE) {
g_fullscreen_width = mode.w;
}
g_fullscreen_height = fs_config_get_int("fullscreen_height");
if (g_fullscreen_height == FS_CONFIG_NONE) {
g_fullscreen_height = mode.h;
}
if (g_fs_emu_video_fullscreen_mode_string == NULL) {
g_fs_emu_video_fullscreen_mode = -1;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"window") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_WINDOW;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"fullscreen") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
}
else if (g_ascii_strcasecmp(g_fs_emu_video_fullscreen_mode_string,
"desktop") == 0) {
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
if (g_fs_emu_video_fullscreen_mode == -1) {
#ifdef MACOSX
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#else
g_fs_emu_video_fullscreen_mode = FULLSCREEN_FULLSCREEN;
#endif
fs_log("[SDL] Defaulting to fullscreen_mode = desktop for SDL 2\n");
g_fs_emu_video_fullscreen_mode = FULLSCREEN_DESKTOP;
}
initialized = 1;
}
if (g_fs_ml_video_sync) {
g_fs_ml_vblank_sync = 1;
}
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (g_fsaa) {
fs_log("setting FSAA samples to %d\n", g_fsaa);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, g_fsaa);
}
g_window_width = fs_config_get_int("window_width");
if (g_window_width == FS_CONFIG_NONE) {
g_window_width = 1920 / 2;
}
g_window_height = fs_config_get_int("window_height");
if (g_window_height == FS_CONFIG_NONE) {
g_window_height = 1080/ 2;
}
g_window_x = fs_config_get_int("window_x");
if (g_window_x == FS_CONFIG_NONE) {
g_window_x = SDL_WINDOWPOS_CENTERED;
}
g_window_y = fs_config_get_int("window_y");
if (g_window_y == FS_CONFIG_NONE) {
g_window_y = SDL_WINDOWPOS_CENTERED;
}
g_window_resizable = fs_config_get_boolean("window_resizable");
if (g_window_resizable == FS_CONFIG_NONE) {
g_window_resizable = 1;
}
g_fs_ml_automatic_input_grab = fs_config_get_boolean(
"automatic_input_grab");
if (g_fs_ml_automatic_input_grab == FS_CONFIG_NONE) {
if (fs_ml_mouse_integration()) {
g_fs_ml_automatic_input_grab = 0;
} else {
g_fs_ml_automatic_input_grab = 1;
}
}
fs_log("automatic input grab: %d\n", g_fs_ml_automatic_input_grab);
g_initial_input_grab = g_fs_ml_automatic_input_grab;
if (fs_config_get_boolean("initial_input_grab") == 1) {
g_initial_input_grab = 1;
}
else if (fs_config_get_boolean("initial_input_grab") == 0 ||
// deprecated names:
fs_config_get_boolean("input_grab") == 0 ||
fs_config_get_boolean("grab_input") == 0) {
g_initial_input_grab = 0;
}
set_video_mode();
if (g_fs_ml_vblank_sync) {
fs_emu_log("*** Setting swap interval to 1 ***\n");
if (SDL_GL_SetSwapInterval(1) != 0) {
fs_emu_warning("SDL_GL_SetSwapInterval(1) failed");
}
}
else {
fs_emu_log("*** Setting swap interval to 0 ***\n");
SDL_GL_SetSwapInterval(0);
}
fs_log("initial input grab: %d\n", g_initial_input_grab);
if (g_initial_input_grab && !g_has_input_grab) {
fs_ml_set_input_grab(true);
}
fs_ml_show_cursor(0, 1);
/* This looks a bit peculiar, but it helps to show the window in
* fullscreen mode as soon as possible to reduce flickering,
at least under GNOME 3. */
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
int64_t start_time = fs_emu_monotonic_time();
SDL_Event event;
while (fs_emu_monotonic_time() - start_time < 100 * 1000) {
SDL_WaitEventTimeout(&event, 10);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(g_fs_ml_window);
}
// this function must be called from the video thread
fs_log("init_opengl\n");
fse_init_video_opengl();
SDL_StartTextInput();
#ifdef WINDOWS
if (!fs_config_false(OPTION_RAW_INPUT)) {
fs_ml_init_raw_input();
}
#endif
fs_log("create windows is done\n");
return 1;
}
int main (int argc, char *argv[])
#endif
{
int err = SDL_Init(SDL_INIT_EVERYTHING);
if (err != 0) {
printf("SDL_Init failed: %s\n", SDL_GetError());
return err;
}
WCLOCK_nxt = CEU_WCLOCK_INACTIVE;
u32 old = SDL_GetTicks();
u32 fps_old = old;
#ifdef CEU_THREADS
// just before executing CEU code
CEU_THREADS_MUTEX_LOCK(&CEU.threads_mutex);
#endif
char CEU_DATA[sizeof(CEU_Main)];
tceu_app app;
app.data = (tceu_org*) &CEU_DATA;
app.init = &ceu_app_init;
app.init(&app); /* calls CEU_THREADS_MUTEX_LOCK() */
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#ifdef CEU_IN_OS_START
ceu_sys_go(&app, CEU_IN_OS_START, (tceu_evtp)NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#endif
#ifdef CEU_IN_SDL_REDRAW
ceu_sys_go(&app, CEU_IN_SDL_REDRAW, (tceu_evtp)NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
#endif
SDL_Event evt;
#ifdef __ANDROID__
int isPaused = 0;
#endif
for (;;)
{
#ifdef CEU_THREADS
// unlock from INIT->START->REDRAW or last loop iteration
CEU_THREADS_MUTEX_UNLOCK(&CEU.threads_mutex);
#endif
#ifndef SDL_SIMUL
/*
* With SDL_DT, 'tm=0' (update as fast as possible).
* Without SDL_DT, 'tm=?' respects the timers.
*/
#ifdef CEU_IN_SDL_DT
s32 tm = 0;
#else
s32 tm = -1;
#ifdef CEU_WCLOCKS
if (WCLOCK_nxt != CEU_WCLOCK_INACTIVE)
tm = WCLOCK_nxt / 1000;
#endif
#ifdef CEU_ASYNCS
if (app.pendingAsyncs) {
tm = 0;
}
#endif
#endif // CEU_IN_SDL_DT
//SDL_EventState(SDL_FINGERMOTION, SDL_IGNORE);
int has;
#ifdef __ANDROID__
if (isPaused) {
has = SDL_WaitEvent(&evt);
} else
#endif
{
has = SDL_WaitEventTimeout(&evt, tm);
}
u32 now = SDL_GetTicks();
if (old == now) now++; // force a minimum change
s32 dt = now - old;
old = now;
// DT/WCLOCK/REDRAW respecting FPS (at most)
int fps_ok = !SDL_PollEvent(NULL);
if (! fps_ok) {
if (old >= fps_old+1000/CEU_SDL_FPS) {
fps_old = old;
fps_ok = 1;
}
}
#ifdef CEU_THREADS
// just before executing CEU code
CEU_THREADS_MUTEX_LOCK(&CEU.threads_mutex);
#endif
#ifdef __ANDROID__
if (!isPaused)
#endif
if (fps_ok) {
#ifdef CEU_WCLOCKS
#ifndef CEU_IN_SDL_DT
if (WCLOCK_nxt != CEU_WCLOCK_INACTIVE)
{
//redraw = WCLOCK_nxt <= 1000*dt;
#endif
ceu_sys_go(&app, CEU_IN__WCLOCK, (tceu_evtp)(1000*dt));
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
while (WCLOCK_nxt <= 0) {
ceu_sys_go(&app, CEU_IN__WCLOCK, (tceu_evtp)0);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#ifndef CEU_IN_SDL_DT
}
#endif
#endif
#ifdef CEU_IN_SDL_DT
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_DT, (tceu_evtp)dt);
}
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
//redraw = 1;
#endif
}
// OTHER EVENTS
if (has)
{
int handled = 1; // =1 for defined events
tceu_evtp evtp = (tceu_evtp)(void*)&evt;
switch (evt.type) {
#ifdef CEU_IN_SDL_QUIT
case SDL_QUIT:
ceu_sys_go(&app, CEU_IN_SDL_QUIT, evtp);
break;
#endif
#ifdef CEU_IN_SDL_WINDOWEVENT
case SDL_WINDOWEVENT:
ceu_sys_go(&app, CEU_IN_SDL_WINDOWEVENT, evtp);
break;
#endif
#ifdef CEU_IN_SDL_KEYDOWN
case SDL_KEYDOWN:
ceu_sys_go(&app, CEU_IN_SDL_KEYDOWN, evtp);
break;
#endif
#ifdef CEU_IN_SDL_KEYUP
case SDL_KEYUP:
ceu_sys_go(&app, CEU_IN_SDL_KEYUP, evtp);
break;
#endif
#ifdef CEU_IN_SDL_TEXTINPUT
case SDL_TEXTINPUT:
ceu_sys_go(&app, CEU_IN_SDL_TEXTINPUT, evtp);
break;
#endif
#ifdef CEU_IN_SDL_TEXTEDITING
case SDL_TEXTEDITING:
ceu_sys_go(&app, CEU_IN_SDL_TEXTEDITING, evtp);
break;
#endif
#ifdef CEU_IN_SDL_MOUSEMOTION
case SDL_MOUSEMOTION:
ceu_sys_go(&app, CEU_IN_SDL_MOUSEMOTION, evtp);
break;
#endif
#ifdef CEU_IN_SDL_MOUSEBUTTONDOWN
case SDL_MOUSEBUTTONDOWN:
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONDOWN, evtp);
break;
#endif
#ifdef CEU_IN_SDL_MOUSEBUTTONUP
case SDL_MOUSEBUTTONUP:
ceu_sys_go(&app, CEU_IN_SDL_MOUSEBUTTONUP, evtp);
break;
#endif
#ifdef CEU_IN_SDL_FINGERDOWN
case SDL_FINGERDOWN:
ceu_sys_go(&app, CEU_IN_SDL_FINGERDOWN, evtp);
break;
#endif
#ifdef CEU_IN_SDL_FINGERUP
case SDL_FINGERUP:
ceu_sys_go(&app, CEU_IN_SDL_FINGERUP, evtp);
break;
#endif
#if defined(CEU_IN_SDL_APP_WILLENTERBACKGROUND) || defined(__ANDROID__)
case SDL_APP_WILLENTERBACKGROUND:
#ifdef __ANDROID__
// handle onPause/onResume
isPaused = 1;
#endif
#ifdef CEU_IN_SDL_APP_WILLENTERBACKGROUND
ceu_sys_go(&app, CEU_IN_SDL_APP_WILLENTERBACKGROUND, evtp);
#endif
break;
#endif
#if defined(CEU_IN_SDL_APP_WILLENTERFOREGROUND) || defined(__ANDROID__)
case SDL_APP_WILLENTERFOREGROUND:
#ifdef __ANDROID__
// handle onPause/onResume
isPaused = 0;
old = SDL_GetTicks(); // ignores previous 'old' on resume
#endif
#ifdef CEU_IN_SDL_APP_WILLENTERFOREGROUND
ceu_sys_go(&app, CEU_IN_SDL_APP_WILLENTERFOREGROUND, evtp);
#endif
break;
#endif
#ifdef CEU_IN_SDL_FINGERMOTION
case SDL_FINGERMOTION:
ceu_sys_go(&app, CEU_IN_SDL_FINGERMOTION, evtp);
break;
#endif
default:
handled = 0; // undefined event
}
#ifdef CEU_RET
if (! app.isAlive) goto END;
#endif
//redraw = redraw || handled;
}
#ifdef CEU_IN_SDL_REDRAW
//if (redraw && !SDL_PollEvent(NULL)) {
if (fps_ok) {
ceu_sys_go(&app, CEU_IN_SDL_REDRAW, (tceu_evtp)NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
#endif // SDL_SIMUL
#ifdef CEU_ASYNCS
if (app.pendingAsyncs) {
ceu_sys_go(&app, CEU_IN__ASYNC, (tceu_evtp)NULL);
#ifdef CEU_RET
if (! app.isAlive)
goto END;
#endif
}
#endif
}
END:
#ifdef CEU_THREADS
// only reachable if LOCKED
CEU_THREADS_MUTEX_UNLOCK(&CEU.threads_mutex);
#endif
SDL_Quit(); // TODO: slow
#ifdef CEU_RET
return app.ret;
#else
return 0;
#endif
}
static bool process_event(SDL_Event *event)
{
struct buffered_status *status = store_status();
enum keycode ckey;
/* SDL's numlock keyboard modifier handling seems to be broken on X11,
* and it will only get numlock's status right on application init. We
* can trust this value once, and then toggle based on user presses of
* the numlock key.
*
* On Windows, KEYDOWN/KEYUP seem to be sent separately, to indicate
* enabling or disabling of numlock. But on X11, both KEYDOWN/KEYUP are
* sent for each toggle, so this must be handled differently.
*
* What a mess!
*/
if(!numlock_status_initialized)
{
status->numlock_status = !!(SDL_GetModState() & KMOD_NUM);
numlock_status_initialized = true;
}
switch(event->type)
{
case SDL_QUIT:
{
// Stuff an escape
status->key = IKEY_ESCAPE;
status->keymap[IKEY_ESCAPE] = 1;
status->keypress_time = get_ticks();
break;
}
#if SDL_VERSION_ATLEAST(2,0,0)
case SDL_WINDOWEVENT:
{
switch(event->window.event)
{
case SDL_WINDOWEVENT_RESIZED:
{
resize_screen(event->window.data1, event->window.data2);
break;
}
case SDL_WINDOWEVENT_FOCUS_LOST:
{
// Pause while minimized
if(input.unfocus_pause)
{
while(1)
{
SDL_WaitEvent(event);
if(event->type == SDL_WINDOWEVENT &&
event->window.event == SDL_WINDOWEVENT_FOCUS_GAINED)
break;
}
}
break;
}
}
break;
}
#else // !SDL_VERSION_ATLEAST(2,0,0)
case SDL_VIDEORESIZE:
{
resize_screen(event->resize.w, event->resize.h);
break;
}
case SDL_ACTIVEEVENT:
{
if(input.unfocus_pause)
{
// Pause while minimized
if(event->active.state & (SDL_APPACTIVE | SDL_APPINPUTFOCUS))
{
// Wait for SDL_APPACTIVE with gain of 1
do
{
SDL_WaitEvent(event);
} while((event->type != SDL_ACTIVEEVENT) ||
(event->active.state & ~(SDL_APPACTIVE | SDL_APPINPUTFOCUS)));
}
}
break;
}
#endif // !SDL_VERSION_ATLEAST(2,0,0)
case SDL_MOUSEMOTION:
{
SDL_Window *window = SDL_GetWindowFromID(sdl_window_id);
int mx_real = event->motion.x;
int my_real = event->motion.y;
int mx, my, min_x, min_y, max_x, max_y;
get_screen_coords(mx_real, my_real, &mx, &my, &min_x,
&min_y, &max_x, &max_y);
if(mx > 639)
SDL_WarpMouseInWindow(window, max_x, my_real);
if(mx < 0)
SDL_WarpMouseInWindow(window, min_x, my_real);
if(my > 349)
SDL_WarpMouseInWindow(window, mx_real, max_y);
if(my < 0)
SDL_WarpMouseInWindow(window, mx_real, min_y);
status->real_mouse_x = mx;
status->real_mouse_y = my;
status->mouse_x = mx / 8;
status->mouse_y = my / 14;
status->mouse_moved = true;
break;
}
case SDL_MOUSEBUTTONDOWN:
{
status->mouse_button = event->button.button;
status->mouse_repeat = event->button.button;
status->mouse_button_state |= SDL_BUTTON(event->button.button);
status->mouse_repeat_state = 1;
status->mouse_drag_state = -1;
status->mouse_time = SDL_GetTicks();
break;
}
case SDL_MOUSEBUTTONUP:
{
status->mouse_button_state &= ~SDL_BUTTON(event->button.button);
status->mouse_repeat = 0;
status->mouse_drag_state = 0;
status->mouse_repeat_state = 0;
break;
}
#if SDL_VERSION_ATLEAST(2,0,0)
// emulate the X11-style "wheel is a button" that SDL 1.2 used
case SDL_MOUSEWHEEL:
{
SDL_Event fake_event;
fake_event.type = SDL_MOUSEBUTTONDOWN;
fake_event.button.windowID = event->wheel.windowID;
fake_event.button.which = event->wheel.which;
fake_event.button.state = SDL_PRESSED;
fake_event.button.x = 0;
fake_event.button.y = 0;
if(event->wheel.y < 0)
fake_event.button.button = MOUSE_BUTTON_WHEELDOWN;
else
fake_event.button.button = MOUSE_BUTTON_WHEELUP;
SDL_PushEvent(&fake_event);
fake_event.type = SDL_MOUSEBUTTONUP;
fake_event.button.state = SDL_RELEASED;
SDL_PushEvent(&fake_event);
break;
}
#endif // SDL_VERSION_ATLEAST(2,0,0)
case SDL_KEYDOWN:
{
Uint16 unicode = 0;
#if SDL_VERSION_ATLEAST(2,0,0)
// FIXME: SDL 2.0 finally implements proper key repeat.
// We should probably use it instead of our hand-rolled stuff.
if(event->key.repeat)
break;
#endif
ckey = convert_SDL_internal(event->key.keysym.sym);
if(!ckey)
{
#if !SDL_VERSION_ATLEAST(2,0,0)
if(!event->key.keysym.unicode)
break;
#endif
ckey = IKEY_UNICODE;
}
#if SDL_VERSION_ATLEAST(2,0,0)
// SDL 2.0 sends the raw key and translated 'text' as separate events.
// There is no longer a UNICODE mode that sends both at once.
// Because of the way the SDL 1.2 assumption is embedded deeply in
// the MZX event queue processor, emulate the 1.2 behaviour by waiting
// for a TEXTINPUT event after a KEYDOWN.
if(SDL_WaitEventTimeout(event, 1))
{
if(event->type == SDL_TEXTINPUT)
unicode = event->text.text[0] | event->text.text[1] << 8;
else
SDL_PushEvent(event);
}
#else
unicode = event->key.keysym.unicode;
#endif
if((ckey == IKEY_RETURN) &&
get_alt_status(keycode_internal) &&
get_ctrl_status(keycode_internal))
{
toggle_fullscreen();
break;
}
if(ckey == IKEY_CAPSLOCK)
{
status->caps_status = true;
}
if(ckey == IKEY_NUMLOCK)
{
#if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__)
status->numlock_status = true;
#endif
break;
}
if(ckey == IKEY_F12)
{
dump_screen();
break;
}
// Ignore alt + tab
if((ckey == IKEY_TAB) && get_alt_status(keycode_internal))
{
break;
}
if(status->key_repeat &&
(status->key_repeat != IKEY_LSHIFT) &&
(status->key_repeat != IKEY_RSHIFT) &&
(status->key_repeat != IKEY_LALT) &&
(status->key_repeat != IKEY_RALT) &&
(status->key_repeat != IKEY_LCTRL) &&
(status->key_repeat != IKEY_RCTRL))
{
// Stack current repeat key if it isn't shift, alt, or ctrl
if(input.repeat_stack_pointer != KEY_REPEAT_STACK_SIZE)
{
input.key_repeat_stack[input.repeat_stack_pointer] =
status->key_repeat;
input.unicode_repeat_stack[input.repeat_stack_pointer] =
status->unicode_repeat;
input.repeat_stack_pointer++;
}
}
key_press(status, ckey, unicode);
break;
}
case SDL_KEYUP:
{
#if SDL_VERSION_ATLEAST(2,0,0)
// FIXME: SDL 2.0 finally implements proper key repeat.
// We should probably use it instead of our hand-rolled stuff.
if(event->key.repeat)
break;
#endif
ckey = convert_SDL_internal(event->key.keysym.sym);
if(!ckey)
{
#if !SDL_VERSION_ATLEAST(2,0,0)
if(!status->keymap[IKEY_UNICODE])
break;
#endif
ckey = IKEY_UNICODE;
}
if(ckey == IKEY_NUMLOCK)
{
#if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__)
status->numlock_status = false;
#else
status->numlock_status = !status->numlock_status;
#endif
break;
}
if(ckey == IKEY_CAPSLOCK)
{
status->caps_status = false;
}
status->keymap[ckey] = 0;
if(status->key_repeat == ckey)
{
status->key_repeat = IKEY_UNKNOWN;
status->unicode_repeat = 0;
}
status->key_release = ckey;
break;
}
case SDL_JOYAXISMOTION:
{
int axis_value = event->jaxis.value;
int digital_value = -1;
int which = event->jaxis.which;
int axis = event->jaxis.axis;
Sint8 last_axis = status->axis[which][axis];
enum keycode stuffed_key;
if(axis_value > 10000)
digital_value = 1;
else
if(axis_value < -10000)
digital_value = 0;
if(digital_value != -1)
{
stuffed_key =
input.joystick_axis_map[which][axis][digital_value];
if(stuffed_key)
{
joystick_key_press(status, stuffed_key, stuffed_key);
if(last_axis == (digital_value ^ 1))
{
joystick_key_release(status,
input.joystick_axis_map[which][axis][last_axis]);
}
}
}
else if(last_axis != -1)
{
joystick_key_release(status,
input.joystick_axis_map[which][axis][last_axis]);
}
status->axis[which][axis] = digital_value;
break;
}
case SDL_JOYBUTTONDOWN:
{
int which = event->jbutton.which;
int button = event->jbutton.button;
enum keycode stuffed_key = input.joystick_button_map[which][button];
if(stuffed_key)
joystick_key_press(status, stuffed_key, stuffed_key);
break;
}
case SDL_JOYBUTTONUP:
{
int which = event->jbutton.which;
int button = event->jbutton.button;
enum keycode stuffed_key = input.joystick_button_map[which][button];
if(stuffed_key)
joystick_key_release(status, stuffed_key);
break;
}
case SDL_JOYHATMOTION:
{
int which = event->jhat.which;
int dir = event->jhat.value;
enum keycode key_up = input.joystick_hat_map[which][0];
enum keycode key_down = input.joystick_hat_map[which][1];
enum keycode key_left = input.joystick_hat_map[which][2];
enum keycode key_right = input.joystick_hat_map[which][3];
//if(dir & SDL_HAT_CENTERED)
{
joystick_key_release(status, key_up);
joystick_key_release(status, key_down);
joystick_key_release(status, key_left);
joystick_key_release(status, key_right);
}
if(dir & SDL_HAT_UP)
{
if (key_up)
joystick_key_press(status, key_up, key_up);
}
if(dir & SDL_HAT_DOWN)
{
if (key_down)
joystick_key_press(status, key_down, key_down);
}
if(dir & SDL_HAT_LEFT)
{
if (key_left)
joystick_key_press(status, key_left, key_left);
}
if(dir & SDL_HAT_RIGHT)
{
if (key_right)
joystick_key_press(status, key_right, key_right);
}
break;
}
default:
return false;
}
return true;
}
