int ceu_go_all (tceu_app* app)
{
/* All code run atomically:
* - the program is always locked as a whole
* - thread spawns will unlock => re-lock
* - but program will still run to completion
*/
app->init(app); /* calls CEU_THREADS_MUTEX_LOCK() */
#ifdef CEU_IN_OS_START
#if defined(CEU_RET) || defined(CEU_OS)
if (app->isAlive)
#endif
ceu_sys_go(app, CEU_IN_OS_START, (tceu_evtp)NULL);
#endif
#ifdef CEU_ASYNCS
while(
#if defined(CEU_RET) || defined(CEU_OS)
app->isAlive &&
#endif
(
#ifdef CEU_THREADS
app->threads_n>0 ||
#endif
app->pendingAsyncs
) )
{
ceu_sys_go(app, CEU_IN__ASYNC, (tceu_evtp)NULL);
#ifdef CEU_THREADS
CEU_THREADS_MUTEX_UNLOCK(&app->threads_mutex);
/* allow threads to also execute */
CEU_THREADS_MUTEX_LOCK(&app->threads_mutex);
#endif
}
#endif
#ifdef CEU_THREADS
CEU_THREADS_MUTEX_UNLOCK(&app->threads_mutex);
#endif
#ifdef CEU_NEWS
#ifdef CEU_RUNTESTS
assert(_ceu_dyns_ == 0);
#endif
#endif
#ifdef CEU_RET
return app->ret;
#else
return 0;
#endif
}
void
input_evt_handler (char **evt, int size)
{
#ifdef CEU_IN_SESSION_CREATED
if (strcmp (evt[0], "SESSION_CREATED") == 0)
{
char *endptr;
int value;
value = (int) strtol (evt[1], &endptr, 10);
if (evt[1] != endptr)
{
ceu_sys_go (&app, CEU_IN_SESSION_CREATED, &value);
}
}
#endif
#ifdef CEU_IN_DEVICE_JOINED
if (strcmp (evt[0], "DEVICE_JOINED") == 0)
{
char *endptr;
pair_int_t pair;
pair.first = (int) strtol (evt[1], &endptr, 10);
if (evt[1] != endptr)
{
pair.second = (int) strtol (evt[2], &endptr, 10);
if (evt[2] != endptr)
ceu_sys_go (&app, CEU_IN_DEVICE_JOINED, &pair);
}
}
#endif
#ifdef CEU_IN_START_MEDIA
if (strcmp (evt[0], "START_MEDIA") == 0)
{
_4tuple_t pair;
char *endptr;
pair.first = (int) strtol (evt[1], &endptr, 10);
if (evt[1] != endptr)
{
pair.second = (int) strtol (evt[2], &endptr, 10);
if (evt[2] != endptr)
{
pair.third = evt[3];
if (sscanf (evt[4], "%" SCNd64 "", &pair.fourth) != EOF)
{
ceu_sys_go (&app, CEU_IN_START_MEDIA, &pair);
}
}
}
}
#endif
}
void execute(struct tceu_app* out) {
ceu_sys_go(out, CEU_IN_START, (void*)0);
/*
int i;
for (i = 100; i < 200; i++) {
printf("...\n");
ceu_sys_go(out, CEU_IN_TICK, &i);
}
*/
}
int main (int argc, char *argv[])
{
byte CEU_DATA[sizeof(CEU_Main)];
memset(CEU_DATA, 0, sizeof(CEU_Main));
tceu_app app;
app.data = (tceu_org*) &CEU_DATA;
app.init = &ceu_app_init;
app.init(&app);
while (app.isAlive) {
if (WCLOCK_nxt != CEU_WCLOCK_INACTIVE) {
s32 dt = WCLOCK_nxt;
printf("dt %dms\n", dt / 1000);
sleep(dt / (1000 * 1000));
ceu_sys_go(&app, CEU_IN__WCLOCK, &dt);
} else if (reply_foo) {
reply_foo = 0;
ceu_sys_go(&app, CEU_IN_FOO, NULL);
}
}
return app.ret;
}
void dropoff(struct planning_state* state, int parcel, int truck, int location) {
int name = state->gensym + 1;
// DROPOFF OPERATOR
// dropoff <parcel> (which is currently in <truck>) at <location>
// after <prereqs>, and name this operation <name>
// preconditions
assert(state->pos[parcel] == truck);
assert(state->pos[truck] == location);
// effects
tceu__int__int__int payload = { parcel, truck, location };
ceu_sys_go(state->plan, CEU_IN_DROPOFF, &payload);
if (state->now[truck] > 0) {
tceu__int__int payload = { state->now[truck], name };
ceu_sys_go(state->plan, CEU_IN_BEFORE, &payload);
}
ceu_sys_go(state->plan, CEU_IN_DONE_CONFIG, &name);
state->now[truck] = name;
state->pos[parcel] = location;
state->gensym = name;
}
void move(struct planning_state* state, int truck, int from, int to) {
int name = state->gensym + 1;
// MOVE OPERATOR
// move <truck> from <from> to <to>,
// after <prereqs>, and name this operation <name>
// preconditions
assert(state->pos[truck] == from);
assert(state->route[to] == from || state->route[from] == to);
// effects
tceu__int__int__int payload = { truck, from, to };
ceu_sys_go(state->plan, CEU_IN_MOVE, &payload);
if (state->now[truck] > 0) {
tceu__int__int payload = { state->now[truck], name };
ceu_sys_go(state->plan, CEU_IN_BEFORE, &payload);
}
ceu_sys_go(state->plan, CEU_IN_DONE_CONFIG, &name);
state->now[truck] = name;
state->pos[truck] = to;
state->gensym = name;
}
void pickup(struct planning_state* state, int parcel, int truck, int location) {
int name = state->gensym + 1;
// PICKUP OPERATOR
// pickup <parcel> with <truck>
// after <prereqs>, and name this operation <name>
// preconditions
assert(state->pos[truck] == location);
assert(state->pos[parcel] == location);
// effects
{
tceu__int__int__int payload = { parcel, truck, location };
ceu_sys_go(state->plan, CEU_IN_PICKUP, &payload);
}
if (state->now[truck] > 0) {
tceu__int__int payload = { state->now[truck], name };
ceu_sys_go(state->plan, CEU_IN_BEFORE, &payload);
}
ceu_sys_go(state->plan, CEU_IN_DONE_CONFIG, &name);
state->now[truck] = name;
state->pos[parcel] = truck;
state->gensym = name;
}
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
}
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
}
void
ScreenManager::display()
{
show_software_cursor(globals::software_cursor);
Uint32 last_ticks = SDL_GetTicks();
float previous_frame_time;
std::vector<Input::Event> events;
while (!screens.empty())
{
events.clear();
Uint32 dt;
// Get time and update Input::Events
if (playback_input)
{
// Get Time
read(std::cin, previous_frame_time);
// Update InputManager so that SDL_QUIT and stuff can be
// handled, even if the basic events are taken from record
input_manager.update(previous_frame_time);
input_controller->clear_events();
read_events(std::cin, events);
//Ceu SDL_DT
dt = previous_frame_time*1000;
int dt_us = 1000*dt;
ceu_sys_go(&CEUapp, CEU_IN__WCLOCK, &dt_us);
ceu_sys_go(&CEUapp, CEU_IN_SDL_DT, &dt);
}
else
{
// Get Time
Uint32 ticks = SDL_GetTicks();
previous_frame_time = float(ticks - last_ticks)/1000.0f;
dt = ticks - last_ticks;
last_ticks = ticks;
// Update InputManager and get Events
input_manager.update(previous_frame_time);
input_controller->poll_events(events);
//Ceu SDL_DT
int dt_us = 1000*dt;
ceu_sys_go(&CEUapp, CEU_IN__WCLOCK, &dt_us);
ceu_sys_go(&CEUapp, CEU_IN_SDL_DT, &dt);
}
if (record_input)
{
write(std::cerr, previous_frame_time);
write_events(std::cerr, events);
}
if (globals::software_cursor)
cursor.update(previous_frame_time);
// previous frame took more than one second
if (previous_frame_time > 1.0)
{
///if (globals::developer_mode)
log_warn("ScreenManager: previous frame took longer than 1 second (%1% sec.), ignoring and doing frameskip", previous_frame_time);
}
else
{
update(previous_frame_time, events);
// cap the framerate at the desired value
// figure out how long this frame took
float current_frame_time = float(SDL_GetTicks() - last_ticks) / 1000.0f;
// idly delay if this frame didn't last long enough to
// achieve <desired_fps> frames per second
if (current_frame_time < 1.0f / globals::desired_fps) {
Uint32 sleep_time = static_cast<Uint32>(1000 *((1.0f / globals::desired_fps) - current_frame_time));
SDL_Delay(sleep_time);
}
}
}
}
static gboolean
bus_cb (GstBus *bus, GstMessage *msg, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (GST_MESSAGE_TYPE(msg))
{
case GST_MESSAGE_EOS:
{
printf ("End of stream\n");
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
{
GstState old_state, new_state;
char buff[1024];
gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
if (GST_ELEMENT(msg->src) == pipeline)
{
if (old_state == GST_STATE_PAUSED && new_state == GST_STATE_PLAYING)
{
#ifdef CEU_IN_ELEMENT_STARTED
ceu_sys_go (&app, CEU_IN_ELEMENT_STARTED, "video1");
#endif
}
else if (new_state == GST_STATE_NULL)
{
#ifdef CEU_IN_ELEMENT_STOPPED
ceu_sys_go (&app, CEU_IN_ELEMENT_STOPPED, "video1");
#endif
}
}
sprintf (buff, "Element %s changed state from %s to %s.\n",
GST_OBJECT_NAME (msg->src),
gst_element_state_get_name (old_state),
gst_element_state_get_name (new_state));
LOG (buff);
break;
}
case GST_MESSAGE_ERROR:
{
char *debug;
GError *error;
gst_message_parse_error (msg, &error, &debug);
fprintf (stderr, "Error (%s): %s\n", GST_OBJECT_NAME(msg->src),
error->message);
fprintf (stderr, "Debugging info: %s\n", debug ? debug : "none");
g_error_free (error);
g_free (debug);
g_main_loop_quit (loop);
break;
}
}
return TRUE;
}
