lpnf
/
lovr
mirror of https://github.com/bjornbytes/lovr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Condense event code a bit;

This commit is contained in:
bjorn 2018-07-26 13:40:15 -07:00
parent 693766cf3b
commit 156c0cde5d
8 changed files with 50 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/api/event.c
View File

@ -33,39 +33,28 @@ static int nextEvent(lua_State* L) {
return 2;
case EVENT_FOCUS:
lua_pushboolean(L, event.data.focus.focused);
return 2;
case EVENT_MOUNT:
lua_pushboolean(L, event.data.mount.mounted);
lua_pushboolean(L, event.data.boolean.value);
return 2;
#ifndef EMSCRIPTEN
case EVENT_THREAD_ERROR:
luax_pushobject(L, event.data.threaderror.thread);
lua_pushstring(L, event.data.threaderror.error);
free((void*) event.data.threaderror.error);
luax_pushobject(L, event.data.thread.thread);
lua_pushstring(L, event.data.thread.error);
free((void*) event.data.thread.error);
return 3;
#endif
case EVENT_CONTROLLER_ADDED:
luax_pushobject(L, event.data.controlleradded.controller);
lovrRelease(event.data.controlleradded.controller);
return 2;
case EVENT_CONTROLLER_REMOVED:
luax_pushobject(L, event.data.controllerremoved.controller);
lovrRelease(event.data.controlleradded.controller);
luax_pushobject(L, event.data.controller.controller);
lovrRelease(event.data.controller.controller);
return 2;
case EVENT_CONTROLLER_PRESSED:
luax_pushobject(L, event.data.controllerpressed.controller);
lua_pushstring(L, ControllerButtons[event.data.controllerpressed.button]);
return 3;
case EVENT_CONTROLLER_RELEASED:
luax_pushobject(L, event.data.controllerreleased.controller);
lua_pushstring(L, ControllerButtons[event.data.controllerpressed.button]);
luax_pushobject(L, event.data.controller.controller);
lua_pushstring(L, ControllerButtons[event.data.controller.button]);
return 3;
default:
@ -114,11 +103,8 @@ int l_lovrEventPush(lua_State* L) {
break;
case EVENT_FOCUS:
data.focus.focused = lua_toboolean(L, 2);
break;
case EVENT_MOUNT:
data.mount.mounted = lua_toboolean(L, 2);
data.boolean.value = lua_toboolean(L, 2);
break;
#ifdef EMSCRIPTEN
@ -126,27 +112,20 @@ int l_lovrEventPush(lua_State* L) {
break;
#else
case EVENT_THREAD_ERROR:
data.threaderror.thread = luax_checktype(L, 2, Thread);
data.threaderror.error = luaL_checkstring(L, 3);
data.thread.thread = luax_checktype(L, 2, Thread);
data.thread.error = luaL_checkstring(L, 3);
break;
#endif
case EVENT_CONTROLLER_ADDED:
data.controlleradded.controller = luax_checktype(L, 2, Controller);
break;
case EVENT_CONTROLLER_REMOVED:
data.controllerremoved.controller = luax_checktype(L, 2, Controller);
data.controller.controller = luax_checktype(L, 2, Controller);
break;
case EVENT_CONTROLLER_PRESSED:
data.controllerpressed.controller = luax_checktype(L, 2, Controller);
data.controllerpressed.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
break;
case EVENT_CONTROLLER_RELEASED:
data.controllerreleased.controller = luax_checktype(L, 2, Controller);
data.controllerreleased.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
data.controller.controller = luax_checktype(L, 2, Controller);
data.controller.button = luaL_checkoption(L, 3, NULL, ControllerButtons);
break;
}

9
src/api/thread.c
View File

@ -27,11 +27,10 @@ static int threadRunner(void* data) {
lovrRelease(thread);
if (thread->error) {
Event event;
event.type = EVENT_THREAD_ERROR;
event.data.threaderror.thread = thread;
event.data.threaderror.error = strdup(thread->error);
lovrEventPush(event);
lovrEventPush((Event) {
.type = EVENT_THREAD_ERROR,
.data.thread = { thread, strdup(thread->error) }
});
lua_close(L);
return 1;
}

35
src/event/event.h
View File

@ -24,49 +24,28 @@ typedef struct {
} QuitEvent;
typedef struct {
bool focused;
} FocusEvent;
typedef struct {
bool mounted;
} MountEvent;
bool value;
} BoolEvent;
#ifndef EMSCRIPTEN
typedef struct {
Thread* thread;
const char* error;
} ThreadErrorEvent;
} ThreadEvent;
#endif
typedef struct {
Controller* controller;
} ControllerAddedEvent;
typedef struct {
Controller* controller;
} ControllerRemovedEvent;
typedef struct {
Controller* controller;
ControllerButton button;
} ControllerPressedEvent;
typedef struct {
Controller* controller;
ControllerButton button;
} ControllerReleasedEvent;
} ControllerEvent;
typedef union {
QuitEvent quit;
FocusEvent focus;
MountEvent mount;
BoolEvent boolean;
#ifndef EMSCRIPTEN
ThreadErrorEvent threaderror;
ThreadEvent thread;
#endif
ControllerAddedEvent controlleradded;
ControllerRemovedEvent controllerremoved;
ControllerPressedEvent controllerpressed;
ControllerReleasedEvent controllerreleased;
ControllerEvent controller;
} EventData;
typedef struct {

2
src/graphics/graphics.c
View File

@ -15,7 +15,7 @@ static GraphicsState state;
static void onCloseWindow(GLFWwindow* window) {
if (window == state.window) {
lovrEventPush((Event) { .type = EVENT_QUIT, .data = { .quit = { false, 0 } } });
lovrEventPush((Event) { .type = EVENT_QUIT, .data.quit = { false, 0 } });
}
}

15
src/headset/fake.c
View File

@ -92,21 +92,14 @@ static void onMouseButton(GLFWwindow* window, int button, int action, int mods)
return;
}
Event event;
Controller* controller;
int i;
vec_foreach(&state.controllers, controller, i) {
if (button == GLFW_MOUSE_BUTTON_RIGHT) {
if (action == GLFW_PRESS) {
event.type = EVENT_CONTROLLER_PRESSED;
event.data.controllerpressed.controller = controller;
event.data.controllerpressed.button = CONTROLLER_BUTTON_TRIGGER;
} else {
event.type = EVENT_CONTROLLER_RELEASED;
event.data.controllerreleased.controller = controller;
event.data.controllerreleased.button = CONTROLLER_BUTTON_TRIGGER;
}
lovrEventPush(event);
lovrEventPush((Event) {
.type = action == GLFW_PRESS ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED,
.data.controller = { controller, CONTROLLER_BUTTON_TRIGGER }
});
}
}
}

36
src/headset/openvr.c
View File

@ -86,11 +86,11 @@ static void openvrRefreshControllers() {
Controller* controller; int i;
vec_foreach_rev(&state.controllers, controller, i) {
if (controller->id != controllerIds[0] && controller->id != controllerIds[1]) {
EventType type = EVENT_CONTROLLER_REMOVED;
EventData data = { .controllerremoved = { controller } };
Event event = { .type = type, .data = data };
lovrRetain(controller);
lovrEventPush(event);
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_REMOVED,
.data.controller = { controller, 0 }
});
vec_splice(&state.controllers, i, 1);
lovrRelease(controller);
}
@ -101,11 +101,11 @@ static void openvrRefreshControllers() {
if ((int) controllerIds[i] != -1) {
controller = openvrAddController(controllerIds[i]);
if (!controller) continue;
EventType type = EVENT_CONTROLLER_ADDED;
EventData data = { .controlleradded = { controller } };
Event event = { .type = type, .data = data };
lovrRetain(controller);
lovrEventPush(event);
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_ADDED,
.data.controller = { controller, 0 }
});
}
}
}
@ -188,8 +188,7 @@ static void openvrPoll() {
bool isPress = vrEvent.eventType == EVREventType_VREvent_ButtonPress;
if (vrEvent.trackedDeviceIndex == state.headsetIndex && vrEvent.data.controller.button == EVRButtonId_k_EButton_ProximitySensor) {
Event event = { .type = EVENT_MOUNT, .data = { .mount = { isPress } } };
lovrEventPush(event);
lovrEventPush((Event) { .type = EVENT_MOUNT, .data.boolean = { isPress } });
break;
}
@ -197,15 +196,10 @@ static void openvrPoll() {
Controller* controller = state.controllers.data[i];
if (controller->id == vrEvent.trackedDeviceIndex) {
ControllerButton button = getButton(vrEvent.data.controller.button, openvrControllerGetHand(controller));
if (isPress) {
EventData data = { .controllerpressed = { controller, button } };
Event event = { .type = EVENT_CONTROLLER_PRESSED, .data = data };
lovrEventPush(event);
} else {
EventData data = { .controllerreleased = { controller, button } };
Event event = { .type = EVENT_CONTROLLER_RELEASED, .data = data };
lovrEventPush(event);
}
lovrEventPush((Event) {
.type = isPress ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED,
.data.controller = { controller, button }
});
break;
}
}
@ -215,9 +209,7 @@ static void openvrPoll() {
case EVREventType_VREvent_InputFocusCaptured:
case EVREventType_VREvent_InputFocusReleased: {
bool isFocused = vrEvent.eventType == EVREventType_VREvent_InputFocusReleased;
EventData data = { .focus = { isFocused } };
Event event = { .type = EVENT_FOCUS, .data = data };
lovrEventPush(event);
lovrEventPush((Event) { .type = EVENT_FOCUS, .data.boolean = { isFocused } });
break;
}

10
src/headset/webvr.c
View File

@ -45,7 +45,7 @@ static void onControllerAdded(uint32_t id) {
lovrRetain(controller);
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_ADDED,
.data = { .controlleradded = { controller } }
.data.controller = { controller, 0 }
});
}
@ -56,7 +56,7 @@ static void onControllerRemoved(uint32_t id) {
lovrRetain(controller);
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_REMOVED,
.data = { .controllerremoved = { controller } }
.data.controller = { controller, 0 }
});
vec_splice(&state.controllers, i, 1);
lovrRelease(controller);
@ -68,21 +68,21 @@ static void onControllerRemoved(uint32_t id) {
static void onControllerPressed(uint32_t id, ControllerButton button) {
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_PRESSED,
.data = { .controllerpressed = { state.controllers.data[id], button } }
.data.controller = { state.controllers.data[id], button }
});
}
static void onControllerReleased(uint32_t id, ControllerButton button) {
lovrEventPush((Event) {
.type = EVENT_CONTROLLER_RELEASED,
.data = { .controllerreleased = { state.controllers.data[id], button } }
.data.controller = { state.controllers.data[id], button }
});
}
static void onMountChanged(bool mounted) {
lovrEventPush((Event) {
.type = EVENT_MOUNT,
.data = { .mount = { mounted } }
.data.boolean = { mounted }
});
}

5
src/lovr.c
View File

@ -131,10 +131,7 @@ bool lovrRun(int argc, char** argv, int* status) {
}
void lovrQuit(int status) {
EventType type = EVENT_QUIT;
EventData data = { .quit = { false, status } };
Event event = { .type = type, .data = data };
lovrEventPush(event);
lovrEventPush((Event) { .type = EVENT_QUIT, .data.quit = { false, status } });
}
const char* lovrGetOS() {