refactor: eliminate src subdirectories for honey files

2 files changed, 0 insertions, 1584 deletions

diff --git a/src/input/input.c b/src/input/input.c
deleted file mode 100644
index a0ccbdc..0000000
--- a/src/input/input.c
+++ /dev/null
@@ -1,1355 +0,0 @@
-#include "input.h"
-
-int honey_mouse_movement_callback_ref = LUA_NOREF;
-int honey_mouse_movement_callback_data_ref = LUA_NOREF;
-
-static void honey_glfw_mouse_movement_callback(honey_window window,
-                                               double x_pos, double y_pos);
-static void honey_glfw_keyboard_callback(honey_window window,
-                                         int key, int scancode,
-                                         int action, int mods);
-
-void honey_setup_keyboard()
-{
-    memset(honey_key_states, 0, sizeof(honey_key_states));
-    memset(honey_key_callbacks, LUA_NOREF, sizeof(honey_key_callbacks));
-    memset(honey_key_callbacks_data, LUA_NOREF, sizeof(honey_key_callbacks_data));
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-void honey_setup_input(lua_State* L)
-{
-    honey_setup_keyboard();
-
-    lua_rawgeti(L, LUA_REGISTRYINDEX, honey_window_info_ref);
-    honey_window_information* info = lua_touserdata(L, -1);
-    lua_pop(L, 1);
-
-    glfwSetKeyCallback(info->window, honey_glfw_keyboard_callback);
-    glfwSetCursorPosCallback(info->window, honey_glfw_mouse_movement_callback);
-    
-    honey_lua_element key_elements[] = {
-        { "unknown", HONEY_INTEGER, { HONEY_KEY_UNKNOWN } },
-        { "space", HONEY_INTEGER, { HONEY_KEY_SPACE } },
-        { "apostrophe", HONEY_INTEGER, { HONEY_KEY_APOSTROPHE } },
-        { "comma", HONEY_INTEGER, { HONEY_KEY_COMMA } },
-        { "minus", HONEY_INTEGER, { HONEY_KEY_MINUS } },
-        { "period", HONEY_INTEGER, { HONEY_KEY_PERIOD } },
-        { "slash", HONEY_INTEGER, { HONEY_KEY_SLASH } },
-        { "0", HONEY_INTEGER, { HONEY_KEY_0 } },
-        { "1", HONEY_INTEGER, { HONEY_KEY_1 } },
-        { "2", HONEY_INTEGER, { HONEY_KEY_2 } },
-        { "3", HONEY_INTEGER, { HONEY_KEY_3 } },
-        { "4", HONEY_INTEGER, { HONEY_KEY_4 } },
-        { "5", HONEY_INTEGER, { HONEY_KEY_5 } },
-        { "6", HONEY_INTEGER, { HONEY_KEY_6 } },
-        { "7", HONEY_INTEGER, { HONEY_KEY_7 } },
-        { "8", HONEY_INTEGER, { HONEY_KEY_8 } },
-        { "9", HONEY_INTEGER, { HONEY_KEY_9 } },
-        { "semicolon", HONEY_INTEGER, { HONEY_KEY_SEMICOLON } },
-        { "equal", HONEY_INTEGER, { HONEY_KEY_EQUAL } },
-        { "a", HONEY_INTEGER, { HONEY_KEY_A } },
-        { "b", HONEY_INTEGER, { HONEY_KEY_B } },
-        { "c", HONEY_INTEGER, { HONEY_KEY_C } },
-        { "d", HONEY_INTEGER, { HONEY_KEY_D } },
-        { "e", HONEY_INTEGER, { HONEY_KEY_E } },
-        { "f", HONEY_INTEGER, { HONEY_KEY_F } },
-        { "g", HONEY_INTEGER, { HONEY_KEY_G } },
-        { "h", HONEY_INTEGER, { HONEY_KEY_H } },
-        { "i", HONEY_INTEGER, { HONEY_KEY_I } },
-        { "j", HONEY_INTEGER, { HONEY_KEY_J } },
-        { "k", HONEY_INTEGER, { HONEY_KEY_K } },
-        { "l", HONEY_INTEGER, { HONEY_KEY_L } },
-        { "m", HONEY_INTEGER, { HONEY_KEY_M } },
-        { "n", HONEY_INTEGER, { HONEY_KEY_N } },
-        { "o", HONEY_INTEGER, { HONEY_KEY_O } },
-        { "p", HONEY_INTEGER, { HONEY_KEY_P } },
-        { "q", HONEY_INTEGER, { HONEY_KEY_Q } },
-        { "r", HONEY_INTEGER, { HONEY_KEY_R } },
-        { "s", HONEY_INTEGER, { HONEY_KEY_S } },
-        { "t", HONEY_INTEGER, { HONEY_KEY_T } },
-        { "u", HONEY_INTEGER, { HONEY_KEY_U } },
-        { "v", HONEY_INTEGER, { HONEY_KEY_V } },
-        { "w", HONEY_INTEGER, { HONEY_KEY_W } },
-        { "x", HONEY_INTEGER, { HONEY_KEY_X } },
-        { "y", HONEY_INTEGER, { HONEY_KEY_Y } },
-        { "z", HONEY_INTEGER, { HONEY_KEY_Z } },
-        { "left_bracket", HONEY_INTEGER, { HONEY_KEY_LEFT_BRACKET } },
-        { "backslash", HONEY_INTEGER, { HONEY_KEY_BACKSLASH } },
-        { "right_bracket", HONEY_INTEGER, { HONEY_KEY_RIGHT_BRACKET } },
-        { "grave_accent", HONEY_INTEGER, { HONEY_KEY_GRAVE_ACCENT } },
-        { "world_1", HONEY_INTEGER, { HONEY_KEY_WORLD_1 } },
-        { "world_2", HONEY_INTEGER, { HONEY_KEY_WORLD_2 } },
-        { "escape", HONEY_INTEGER, { HONEY_KEY_ESCAPE } },
-        { "enter", HONEY_INTEGER, { HONEY_KEY_ENTER } },
-        { "tab", HONEY_INTEGER, { HONEY_KEY_TAB } },
-        { "backspace", HONEY_INTEGER, { HONEY_KEY_BACKSPACE } },
-        { "insert", HONEY_INTEGER, { HONEY_KEY_INSERT } },
-        { "delete", HONEY_INTEGER, { HONEY_KEY_DELETE } },
-        { "right", HONEY_INTEGER, { HONEY_KEY_RIGHT } },
-        { "left", HONEY_INTEGER, { HONEY_KEY_LEFT } },
-        { "down", HONEY_INTEGER, { HONEY_KEY_DOWN } },
-        { "up", HONEY_INTEGER, { HONEY_KEY_UP } },
-        { "page_up", HONEY_INTEGER, { HONEY_KEY_PAGE_UP } },
-        { "page_down", HONEY_INTEGER, { HONEY_KEY_PAGE_DOWN } },
-        { "home", HONEY_INTEGER, { HONEY_KEY_HOME } },
-        { "end", HONEY_INTEGER, { HONEY_KEY_END } },
-        { "caps_lock", HONEY_INTEGER, { HONEY_KEY_CAPS_LOCK } },
-        { "scroll_lock", HONEY_INTEGER, { HONEY_KEY_SCROLL_LOCK } },
-        { "num_lock", HONEY_INTEGER, { HONEY_KEY_NUM_LOCK } },
-        { "print_screen", HONEY_INTEGER, { HONEY_KEY_PRINT_SCREEN } },
-        { "pause", HONEY_INTEGER, { HONEY_KEY_PAUSE } },
-        { "f1", HONEY_INTEGER, { HONEY_KEY_F1 } },
-        { "f2", HONEY_INTEGER, { HONEY_KEY_F2 } },
-        { "f3", HONEY_INTEGER, { HONEY_KEY_F3 } },
-        { "f4", HONEY_INTEGER, { HONEY_KEY_F4 } },
-        { "f5", HONEY_INTEGER, { HONEY_KEY_F5 } },
-        { "f6", HONEY_INTEGER, { HONEY_KEY_F6 } },
-        { "f7", HONEY_INTEGER, { HONEY_KEY_F7 } },
-        { "f8", HONEY_INTEGER, { HONEY_KEY_F8 } },
-        { "f9", HONEY_INTEGER, { HONEY_KEY_F9 } },
-        { "f10", HONEY_INTEGER, { HONEY_KEY_F10 } },
-        { "f11", HONEY_INTEGER, { HONEY_KEY_F11 } },
-        { "f12", HONEY_INTEGER, { HONEY_KEY_F12 } },
-        { "f13", HONEY_INTEGER, { HONEY_KEY_F13 } },
-        { "f14", HONEY_INTEGER, { HONEY_KEY_F14 } },
-        { "f15", HONEY_INTEGER, { HONEY_KEY_F15 } },
-        { "f16", HONEY_INTEGER, { HONEY_KEY_F16 } },
-        { "f17", HONEY_INTEGER, { HONEY_KEY_F17 } },
-        { "f18", HONEY_INTEGER, { HONEY_KEY_F18 } },
-        { "f19", HONEY_INTEGER, { HONEY_KEY_F19 } },
-        { "f20", HONEY_INTEGER, { HONEY_KEY_F20 } },
-        { "f21", HONEY_INTEGER, { HONEY_KEY_F21 } },
-        { "f22", HONEY_INTEGER, { HONEY_KEY_F22 } },
-        { "f23", HONEY_INTEGER, { HONEY_KEY_F23 } },
-        { "f24", HONEY_INTEGER, { HONEY_KEY_F24 } },
-        { "f25", HONEY_INTEGER, { HONEY_KEY_F25 } },
-        { "kp_0", HONEY_INTEGER, { HONEY_KEY_KP_0 } },
-        { "kp_1", HONEY_INTEGER, { HONEY_KEY_KP_1 } },
-        { "kp_2", HONEY_INTEGER, { HONEY_KEY_KP_2 } },
-        { "kp_3", HONEY_INTEGER, { HONEY_KEY_KP_3 } },
-        { "kp_4", HONEY_INTEGER, { HONEY_KEY_KP_4 } },
-        { "kp_5", HONEY_INTEGER, { HONEY_KEY_KP_5 } },
-        { "kp_6", HONEY_INTEGER, { HONEY_KEY_KP_6 } },
-        { "kp_7", HONEY_INTEGER, { HONEY_KEY_KP_7 } },
-        { "kp_8", HONEY_INTEGER, { HONEY_KEY_KP_8 } },
-        { "kp_9", HONEY_INTEGER, { HONEY_KEY_KP_9 } },
-        { "kp_decimal", HONEY_INTEGER, { HONEY_KEY_KP_DECIMAL } },
-        { "kp_divide", HONEY_INTEGER, { HONEY_KEY_KP_DIVIDE } },
-        { "kp_multiply", HONEY_INTEGER, { HONEY_KEY_KP_MULTIPLY } },
-        { "kp_subtract", HONEY_INTEGER, { HONEY_KEY_KP_SUBTRACT } },
-        { "kp_add", HONEY_INTEGER, { HONEY_KEY_KP_ADD } },
-        { "kp_enter", HONEY_INTEGER, { HONEY_KEY_KP_ENTER } },
-        { "kp_equal", HONEY_INTEGER, { HONEY_KEY_KP_EQUAL } },
-        { "left_shift", HONEY_INTEGER, { HONEY_KEY_LEFT_SHIFT } },
-        { "left_control", HONEY_INTEGER, { HONEY_KEY_LEFT_CONTROL } },
-        { "left_alt", HONEY_INTEGER, { HONEY_KEY_LEFT_ALT } },
-        { "left_super", HONEY_INTEGER, { HONEY_KEY_LEFT_SUPER } },
-        { "right_shift", HONEY_INTEGER, { HONEY_KEY_RIGHT_SHIFT } },
-        { "right_control", HONEY_INTEGER, { HONEY_KEY_RIGHT_CONTROL } },
-        { "right_alt", HONEY_INTEGER, { HONEY_KEY_RIGHT_ALT } },
-        { "right_super", HONEY_INTEGER, { HONEY_KEY_RIGHT_SUPER } },
-        { "menu", HONEY_INTEGER, { HONEY_KEY_MENU } },
-        { "is_down", HONEY_FUNCTION, { .function = honey_key_down } },
-        { "bind", HONEY_FUNCTION, { .function = honey_key_bind } },
-        { "unbind", HONEY_FUNCTION, { .function = honey_key_unbind } },
-        { "unbind_all", HONEY_FUNCTION, { .function = honey_key_unbind_all } },
-    };
-
-    honey_lua_element mouse_mode_elements[] = {
-        { "normal", HONEY_INTEGER, { .integer = HONEY_MOUSE_MODE_NORMAL } },
-        { "hidden", HONEY_INTEGER, { .integer = HONEY_MOUSE_MODE_HIDDEN } },
-        { "disabled", HONEY_INTEGER, { .integer = HONEY_MOUSE_MODE_DISABLED } },
-    };
-
-    honey_lua_element mouse_elements[] = {
-        { "mode", HONEY_TABLE, { .table = { 3, mouse_mode_elements } } },
-        { "set_mode", HONEY_FUNCTION, { .function = honey_mouse_set_mode } },
-        { "bind_movement",   HONEY_FUNCTION, { .function = honey_mouse_movement_bind } },
-        { "unbind_movement", HONEY_FUNCTION, { .function = honey_mouse_movement_unbind } },
-    };
-
-    honey_lua_element input_elements[] = {
-        { "key",   HONEY_TABLE, { .table={ HONEY_N_KEYS+4, key_elements } } },
-        { "mouse", HONEY_TABLE, { .table={ 4, mouse_elements } } },
-    };
-
-    honey_lua_create_table(L, input_elements, 2);
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_key_down(lua_State* L)
-{
-    if (!lua_isnumber(L, 1))
-        return 0;
-
-    int key = lua_tointeger(L, 1);
-    if (key < 0 || key >= HONEY_N_KEYS)
-        lua_pushboolean(L, false);
-    else
-        lua_pushboolean(L, honey_key_states[key]);
-
-    return 1;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_key_bind(lua_State* L)
-{
-    /* lua params: (int) key, (func) callback, (arb) data */
-    int n_args = lua_gettop(L);
-    if (n_args == 3) {
-        if (!honey_lua_validate_types(L, 3, HONEY_INTEGER, HONEY_FUNCTION, HONEY_ANY)) {
-            lua_error(L);
-        }
-    }
-    else if (n_args == 2) {
-        if (!honey_lua_validate_types(L, 2, HONEY_INTEGER, HONEY_FUNCTION)) {
-            lua_error(L);
-        }
-    }
-    else {
-        char* error_message;
-        honey_format_string(&error_message, "expected 2 or 3 arguments; received %d instead", n_args);
-        lua_pushstring(L, error_message);
-        free(error_message);
-        lua_error(L);
-    }
-
-    int key = lua_tointeger(L, 1);
-    lua_pushvalue(L, 2);
-    int callback = luaL_ref(L, LUA_REGISTRYINDEX);
-    lua_pushvalue(L, 3);
-    int data = luaL_ref(L, LUA_REGISTRYINDEX);
-
-    /* avoid potential memory leak */
-    lua_pushcfunction(L, honey_key_unbind);
-    lua_pushinteger(L, key);
-    honey_lua_pcall(L, 1, 0);
-
-    if (key >= 0 && key < HONEY_N_KEYS) {
-        honey_key_callbacks[key] = callback;
-        honey_key_callbacks_data[key] = data;
-    }
-
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_key_unbind(lua_State* L)
-{
-    /* lua params: (int) key */
-    if (!honey_lua_validate_types(L, 1, HONEY_INTEGER))
-        lua_error(L);
-
-    int key = lua_tointeger(L, 1);
-    
-    if (key >=0 && key < HONEY_N_KEYS) {
-        honey_key_callbacks[key] = LUA_NOREF;
-        honey_key_callbacks_data[key] = LUA_NOREF;
-    }
-    else {
-        char* error_message;
-        honey_format_string(&error_message, "'%d' is not a valid keycode", key);
-        lua_pushstring(L, error_message);
-        free(error_message);
-        lua_error(L);
-    }
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_key_unbind_all(lua_State* L)
-{
-    for (int i=0; i<HONEY_N_KEYS; i++) {
-        honey_key_callbacks[i] = LUA_NOREF;
-        honey_key_callbacks_data[i] = LUA_NOREF;
-    }
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_mouse_set_mode(lua_State* L)
-{
-    if (!honey_lua_validate_types(L, 1, HONEY_INTEGER))
-        lua_error(L);
-
-    int cursor_mode = lua_tointeger(L, 1);
-
-    if (honey_window_info_ref == LUA_NOREF ||
-        honey_window_info_ref == LUA_REFNIL) {
-        lua_pushstring(L, "ERROR: no window set!");
-        lua_error(L);
-    }
-    
-    lua_rawgeti(L, LUA_REGISTRYINDEX, honey_window_info_ref);
-    honey_window_information* info = lua_touserdata(L, -1);
-
-    glfwSetInputMode(info->window, GLFW_CURSOR, cursor_mode);
-
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_mouse_movement_bind(lua_State* L)
-{
-    if (!honey_lua_validate_types(L, 2, HONEY_FUNCTION, HONEY_ANY))
-        lua_error(L);
-
-    honey_mouse_movement_unbind(L); /* avoid memory leaks! */
-    
-    lua_pushvalue(L, 1);
-    honey_mouse_movement_callback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
-    lua_pushvalue(L, 2);
-    honey_mouse_movement_callback_data_ref = luaL_ref(L, LUA_REGISTRYINDEX);
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-int honey_mouse_movement_unbind(lua_State* L)
-{
-    int callback = honey_mouse_movement_callback_ref;
-    int data = honey_mouse_movement_callback_data_ref;
-
-    if (callback != LUA_NOREF || callback != LUA_REFNIL) {
-        lua_pushnil(L);
-        lua_rawseti(L, LUA_REGISTRYINDEX, callback);
-    }
-
-    if (data != LUA_NOREF || data != LUA_REFNIL) {
-        lua_pushnil(L);
-        lua_rawseti(L, LUA_REGISTRYINDEX, data);
-    }
-
-    honey_mouse_movement_callback_ref = LUA_NOREF;
-    honey_mouse_movement_callback_data_ref = LUA_NOREF;
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-static void honey_glfw_mouse_movement_callback(honey_window window,
-                                               double x_pos, double y_pos)
-{
-    int callback = honey_mouse_movement_callback_ref;
-    int data = honey_mouse_movement_callback_data_ref;
-    lua_State* L = glfwGetWindowUserPointer(window);
-    
-    if (callback == LUA_NOREF || callback == LUA_REFNIL)
-        return;
-
-    lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
-    lua_pushnumber(L, x_pos);
-    lua_pushnumber(L, y_pos);
-
-    if (data == LUA_NOREF || data == LUA_REFNIL)
-        lua_pushnil(L);
-    else
-        lua_rawgeti(L, LUA_REGISTRYINDEX, data);
-
-    honey_lua_pcall(L, 3, 0);
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-static void execute_lua_key_callback(lua_State* L, int callback, int action, int data)
-{
-    if (callback != LUA_NOREF) {
-        lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
-        lua_pushinteger(L, action);
-        if (data != LUA_REFNIL)
-            lua_rawgeti(L, LUA_REGISTRYINDEX, data);
-        else
-            lua_pushnil(L);
-        honey_lua_pcall(L, 2, 0);
-    }
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
-
-static void honey_glfw_keyboard_callback(honey_window window,
-                                         int key, int scancode,
-                                         int action, int mods)
-{
-    int callback, data;
-    lua_State* L = glfwGetWindowUserPointer(window);
-    switch (key) {
-    case GLFW_KEY_UNKNOWN:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_UNKNOWN] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_UNKNOWN] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_UNKNOWN];
-        data = honey_key_callbacks_data[HONEY_KEY_UNKNOWN];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_SPACE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SPACE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SPACE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_SPACE];
-        data = honey_key_callbacks_data[HONEY_KEY_SPACE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_APOSTROPHE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_APOSTROPHE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_APOSTROPHE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_APOSTROPHE];
-        data = honey_key_callbacks_data[HONEY_KEY_APOSTROPHE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_COMMA:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_COMMA] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_COMMA] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_COMMA];
-        data = honey_key_callbacks_data[HONEY_KEY_COMMA];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_MINUS:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_MINUS] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_MINUS] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_MINUS];
-        data = honey_key_callbacks_data[HONEY_KEY_MINUS];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_PERIOD:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PERIOD] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PERIOD] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_PERIOD];
-        data = honey_key_callbacks_data[HONEY_KEY_PERIOD];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_SLASH:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SLASH] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SLASH] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_SLASH];
-        data = honey_key_callbacks_data[HONEY_KEY_SLASH];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_0:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_0] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_0] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_0];
-        data = honey_key_callbacks_data[HONEY_KEY_0];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_1:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_1] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_1] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_1];
-        data = honey_key_callbacks_data[HONEY_KEY_1];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_2:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_2] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_2] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_2];
-        data = honey_key_callbacks_data[HONEY_KEY_2];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_3:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_3] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_3] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_3];
-        data = honey_key_callbacks_data[HONEY_KEY_3];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_4:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_4] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_4] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_4];
-        data = honey_key_callbacks_data[HONEY_KEY_4];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_5:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_5] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_5] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_5];
-        data = honey_key_callbacks_data[HONEY_KEY_5];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_6:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_6] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_6] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_6];
-        data = honey_key_callbacks_data[HONEY_KEY_6];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_7:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_7] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_7] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_7];
-        data = honey_key_callbacks_data[HONEY_KEY_7];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_8:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_8] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_8] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_8];
-        data = honey_key_callbacks_data[HONEY_KEY_8];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_9:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_9] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_9] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_9];
-        data = honey_key_callbacks_data[HONEY_KEY_9];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_SEMICOLON:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SEMICOLON] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SEMICOLON] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_SEMICOLON];
-        data = honey_key_callbacks_data[HONEY_KEY_SEMICOLON];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_EQUAL:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_EQUAL] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_EQUAL] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_EQUAL];
-        data = honey_key_callbacks_data[HONEY_KEY_EQUAL];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_A:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_A] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_A] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_A];
-        data = honey_key_callbacks_data[HONEY_KEY_A];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_B:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_B] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_B] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_B];
-        data = honey_key_callbacks_data[HONEY_KEY_B];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_C:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_C] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_C] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_C];
-        data = honey_key_callbacks_data[HONEY_KEY_C];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_D:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_D] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_D] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_D];
-        data = honey_key_callbacks_data[HONEY_KEY_D];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_E:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_E] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_E] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_E];
-        data = honey_key_callbacks_data[HONEY_KEY_E];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F];
-        data = honey_key_callbacks_data[HONEY_KEY_F];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_G:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_G] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_G] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_G];
-        data = honey_key_callbacks_data[HONEY_KEY_G];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_H:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_H] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_H] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_H];
-        data = honey_key_callbacks_data[HONEY_KEY_H];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_I:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_I] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_I] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_I];
-        data = honey_key_callbacks_data[HONEY_KEY_I];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_J:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_J] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_J] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_J];
-        data = honey_key_callbacks_data[HONEY_KEY_J];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_K:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_K] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_K] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_K];
-        data = honey_key_callbacks_data[HONEY_KEY_K];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_L:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_L] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_L] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_L];
-        data = honey_key_callbacks_data[HONEY_KEY_L];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_M:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_M] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_M] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_M];
-        data = honey_key_callbacks_data[HONEY_KEY_M];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_N:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_N] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_N] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_N];
-        data = honey_key_callbacks_data[HONEY_KEY_N];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_O:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_O] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_O] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_O];
-        data = honey_key_callbacks_data[HONEY_KEY_O];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_P:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_P] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_P] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_P];
-        data = honey_key_callbacks_data[HONEY_KEY_P];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_Q:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Q] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Q] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_Q];
-        data = honey_key_callbacks_data[HONEY_KEY_Q];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_R:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_R] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_R] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_R];
-        data = honey_key_callbacks_data[HONEY_KEY_R];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_S:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_S] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_S] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_S];
-        data = honey_key_callbacks_data[HONEY_KEY_S];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_T:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_T] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_T] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_T];
-        data = honey_key_callbacks_data[HONEY_KEY_T];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_U:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_U] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_U] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_U];
-        data = honey_key_callbacks_data[HONEY_KEY_U];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_V:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_V] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_V] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_V];
-        data = honey_key_callbacks_data[HONEY_KEY_V];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_W:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_W] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_W] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_W];
-        data = honey_key_callbacks_data[HONEY_KEY_W];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_X:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_X] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_X] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_X];
-        data = honey_key_callbacks_data[HONEY_KEY_X];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_Y:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Y] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Y] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_Y];
-        data = honey_key_callbacks_data[HONEY_KEY_Y];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_Z:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Z] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Z] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_Z];
-        data = honey_key_callbacks_data[HONEY_KEY_Z];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT_BRACKET:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_BRACKET] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_BRACKET] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT_BRACKET];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT_BRACKET];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_BACKSLASH:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_BACKSLASH] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_BACKSLASH] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_BACKSLASH];
-        data = honey_key_callbacks_data[HONEY_KEY_BACKSLASH];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT_BRACKET:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_BRACKET] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_BRACKET] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT_BRACKET];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_BRACKET];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_GRAVE_ACCENT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_GRAVE_ACCENT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_GRAVE_ACCENT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_GRAVE_ACCENT];
-        data = honey_key_callbacks_data[HONEY_KEY_GRAVE_ACCENT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_WORLD_1:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_WORLD_1] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_WORLD_1] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_WORLD_1];
-        data = honey_key_callbacks_data[HONEY_KEY_WORLD_1];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_WORLD_2:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_WORLD_2] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_WORLD_2] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_WORLD_2];
-        data = honey_key_callbacks_data[HONEY_KEY_WORLD_2];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_ESCAPE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_ESCAPE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_ESCAPE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_ESCAPE];
-        data = honey_key_callbacks_data[HONEY_KEY_ESCAPE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_ENTER:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_ENTER] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_ENTER] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_ENTER];
-        data = honey_key_callbacks_data[HONEY_KEY_ENTER];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_TAB:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_TAB] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_TAB] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_TAB];
-        data = honey_key_callbacks_data[HONEY_KEY_TAB];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_BACKSPACE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_BACKSPACE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_BACKSPACE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_BACKSPACE];
-        data = honey_key_callbacks_data[HONEY_KEY_BACKSPACE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_INSERT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_INSERT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_INSERT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_INSERT];
-        data = honey_key_callbacks_data[HONEY_KEY_INSERT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_DELETE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_DELETE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_DELETE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_DELETE];
-        data = honey_key_callbacks_data[HONEY_KEY_DELETE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_DOWN:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_DOWN] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_DOWN] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_DOWN];
-        data = honey_key_callbacks_data[HONEY_KEY_DOWN];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_UP:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_UP] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_UP] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_UP];
-        data = honey_key_callbacks_data[HONEY_KEY_UP];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_PAGE_UP:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAGE_UP] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAGE_UP] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_PAGE_UP];
-        data = honey_key_callbacks_data[HONEY_KEY_PAGE_UP];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_PAGE_DOWN:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAGE_DOWN] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAGE_DOWN] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_PAGE_DOWN];
-        data = honey_key_callbacks_data[HONEY_KEY_PAGE_DOWN];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_HOME:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_HOME] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_HOME] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_HOME];
-        data = honey_key_callbacks_data[HONEY_KEY_HOME];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_END:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_END] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_END] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_END];
-        data = honey_key_callbacks_data[HONEY_KEY_END];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_CAPS_LOCK:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_CAPS_LOCK] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_CAPS_LOCK] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_CAPS_LOCK];
-        data = honey_key_callbacks_data[HONEY_KEY_CAPS_LOCK];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_SCROLL_LOCK:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SCROLL_LOCK] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SCROLL_LOCK] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_SCROLL_LOCK];
-        data = honey_key_callbacks_data[HONEY_KEY_SCROLL_LOCK];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_NUM_LOCK:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_NUM_LOCK] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_NUM_LOCK] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_NUM_LOCK];
-        data = honey_key_callbacks_data[HONEY_KEY_NUM_LOCK];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_PRINT_SCREEN:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PRINT_SCREEN] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PRINT_SCREEN] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_PRINT_SCREEN];
-        data = honey_key_callbacks_data[HONEY_KEY_PRINT_SCREEN];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_PAUSE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAUSE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAUSE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_PAUSE];
-        data = honey_key_callbacks_data[HONEY_KEY_PAUSE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F1:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F1] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F1] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F1];
-        data = honey_key_callbacks_data[HONEY_KEY_F1];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F2:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F2] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F2] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F2];
-        data = honey_key_callbacks_data[HONEY_KEY_F2];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F3:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F3] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F3] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F3];
-        data = honey_key_callbacks_data[HONEY_KEY_F3];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F4:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F4] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F4] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F4];
-        data = honey_key_callbacks_data[HONEY_KEY_F4];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F5:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F5] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F5] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F5];
-        data = honey_key_callbacks_data[HONEY_KEY_F5];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F6:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F6] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F6] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F6];
-        data = honey_key_callbacks_data[HONEY_KEY_F6];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F7:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F7] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F7] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F7];
-        data = honey_key_callbacks_data[HONEY_KEY_F7];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F8:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F8] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F8] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F8];
-        data = honey_key_callbacks_data[HONEY_KEY_F8];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F9:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F9] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F9] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F9];
-        data = honey_key_callbacks_data[HONEY_KEY_F9];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F10:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F10] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F10] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F10];
-        data = honey_key_callbacks_data[HONEY_KEY_F10];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F11:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F11] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F11] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F11];
-        data = honey_key_callbacks_data[HONEY_KEY_F11];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F12:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F12] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F12] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F12];
-        data = honey_key_callbacks_data[HONEY_KEY_F12];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F13:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F13] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F13] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F13];
-        data = honey_key_callbacks_data[HONEY_KEY_F13];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F14:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F14] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F14] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F14];
-        data = honey_key_callbacks_data[HONEY_KEY_F14];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F15:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F15] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F15] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F15];
-        data = honey_key_callbacks_data[HONEY_KEY_F15];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F16:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F16] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F16] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F16];
-        data = honey_key_callbacks_data[HONEY_KEY_F16];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F17:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F17] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F17] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F17];
-        data = honey_key_callbacks_data[HONEY_KEY_F17];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F18:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F18] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F18] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F18];
-        data = honey_key_callbacks_data[HONEY_KEY_F18];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F19:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F19] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F19] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F19];
-        data = honey_key_callbacks_data[HONEY_KEY_F19];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F20:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F20] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F20] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F20];
-        data = honey_key_callbacks_data[HONEY_KEY_F20];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F21:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F21] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F21] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F21];
-        data = honey_key_callbacks_data[HONEY_KEY_F21];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F22:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F22] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F22] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F22];
-        data = honey_key_callbacks_data[HONEY_KEY_F22];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F23:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F23] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F23] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F23];
-        data = honey_key_callbacks_data[HONEY_KEY_F23];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F24:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F24] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F24] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F24];
-        data = honey_key_callbacks_data[HONEY_KEY_F24];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_F25:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F25] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F25] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_F25];
-        data = honey_key_callbacks_data[HONEY_KEY_F25];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_0:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_0] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_0] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_0];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_0];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_1:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_1] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_1] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_1];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_1];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_2:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_2] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_2] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_2];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_2];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_3:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_3] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_3] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_3];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_3];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_4:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_4] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_4] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_4];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_4];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_5:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_5] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_5] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_5];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_5];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_6:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_6] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_6] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_6];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_6];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_7:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_7] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_7] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_7];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_7];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_8:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_8] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_8] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_8];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_8];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_9:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_9] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_9] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_9];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_9];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_DECIMAL:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_DECIMAL] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_DECIMAL] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_DECIMAL];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_DECIMAL];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_DIVIDE:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_DIVIDE] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_DIVIDE] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_DIVIDE];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_DIVIDE];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_MULTIPLY:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_MULTIPLY] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_MULTIPLY] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_MULTIPLY];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_MULTIPLY];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_SUBTRACT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_SUBTRACT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_SUBTRACT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_SUBTRACT];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_SUBTRACT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_ADD:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_ADD] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_ADD] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_ADD];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_ADD];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_ENTER:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_ENTER] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_ENTER] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_ENTER];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_ENTER];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_KP_EQUAL:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_EQUAL] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_EQUAL] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_KP_EQUAL];
-        data = honey_key_callbacks_data[HONEY_KEY_KP_EQUAL];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT_SHIFT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_SHIFT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_SHIFT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT_SHIFT];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT_SHIFT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT_CONTROL:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_CONTROL] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_CONTROL] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT_CONTROL];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT_CONTROL];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT_ALT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_ALT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_ALT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT_ALT];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT_ALT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_LEFT_SUPER:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_SUPER] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_SUPER] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_LEFT_SUPER];
-        data = honey_key_callbacks_data[HONEY_KEY_LEFT_SUPER];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT_SHIFT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_SHIFT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_SHIFT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT_SHIFT];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_SHIFT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT_CONTROL:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_CONTROL] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_CONTROL] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT_CONTROL];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_CONTROL];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT_ALT:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_ALT] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_ALT] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT_ALT];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_ALT];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_RIGHT_SUPER:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_SUPER] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_SUPER] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_RIGHT_SUPER];
-        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_SUPER];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    case GLFW_KEY_MENU:
-        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_MENU] = 1; }
-        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_MENU] = 0; }
-        callback = honey_key_callbacks[HONEY_KEY_MENU];
-        data = honey_key_callbacks_data[HONEY_KEY_MENU];
-        execute_lua_key_callback(L, callback, action, data);
-        break;
-        
-    default:
-        /* do nothing */
-        break;
-    }
-}
diff --git a/src/input/input.h b/src/input/input.h
deleted file mode 100644
index 7fd3293..0000000
--- a/src/input/input.h
+++ /dev/null
@@ -1,229 +0,0 @@
-#ifndef HONEY_INPUT_H
-#define HONEY_INPUT_H
-
-/** @file input.h
- *
- * @brief Wrap GLFW input functions for honey.
- */
-
-#include "../common.h"
-
-#define HONEY_KEY_UNKNOWN 0
-#define HONEY_KEY_SPACE 1
-#define HONEY_KEY_APOSTROPHE 2
-#define HONEY_KEY_COMMA 3
-#define HONEY_KEY_MINUS 4
-#define HONEY_KEY_PERIOD 5
-#define HONEY_KEY_SLASH 6
-#define HONEY_KEY_0 7
-#define HONEY_KEY_1 8
-#define HONEY_KEY_2 9
-#define HONEY_KEY_3 10
-#define HONEY_KEY_4 11
-#define HONEY_KEY_5 12
-#define HONEY_KEY_6 13
-#define HONEY_KEY_7 14
-#define HONEY_KEY_8 15
-#define HONEY_KEY_9 16
-#define HONEY_KEY_SEMICOLON 17
-#define HONEY_KEY_EQUAL 18
-#define HONEY_KEY_A 19
-#define HONEY_KEY_B 20
-#define HONEY_KEY_C 21
-#define HONEY_KEY_D 22
-#define HONEY_KEY_E 23
-#define HONEY_KEY_F 24
-#define HONEY_KEY_G 25
-#define HONEY_KEY_H 26
-#define HONEY_KEY_I 27
-#define HONEY_KEY_J 28
-#define HONEY_KEY_K 29
-#define HONEY_KEY_L 30
-#define HONEY_KEY_M 31
-#define HONEY_KEY_N 32
-#define HONEY_KEY_O 33
-#define HONEY_KEY_P 34
-#define HONEY_KEY_Q 35
-#define HONEY_KEY_R 36
-#define HONEY_KEY_S 37
-#define HONEY_KEY_T 38
-#define HONEY_KEY_U 39
-#define HONEY_KEY_V 40
-#define HONEY_KEY_W 41
-#define HONEY_KEY_X 42
-#define HONEY_KEY_Y 43
-#define HONEY_KEY_Z 44
-#define HONEY_KEY_LEFT_BRACKET 45
-#define HONEY_KEY_BACKSLASH 46
-#define HONEY_KEY_RIGHT_BRACKET 47
-#define HONEY_KEY_GRAVE_ACCENT 48
-#define HONEY_KEY_WORLD_1 49
-#define HONEY_KEY_WORLD_2 50
-#define HONEY_KEY_ESCAPE 51
-#define HONEY_KEY_ENTER 52
-#define HONEY_KEY_TAB 53
-#define HONEY_KEY_BACKSPACE 54
-#define HONEY_KEY_INSERT 55
-#define HONEY_KEY_DELETE 56
-#define HONEY_KEY_RIGHT 57
-#define HONEY_KEY_LEFT 58
-#define HONEY_KEY_DOWN 59
-#define HONEY_KEY_UP 60
-#define HONEY_KEY_PAGE_UP 61
-#define HONEY_KEY_PAGE_DOWN 62
-#define HONEY_KEY_HOME 63
-#define HONEY_KEY_END 64
-#define HONEY_KEY_CAPS_LOCK 65
-#define HONEY_KEY_SCROLL_LOCK 66
-#define HONEY_KEY_NUM_LOCK 67
-#define HONEY_KEY_PRINT_SCREEN 68
-#define HONEY_KEY_PAUSE 69
-#define HONEY_KEY_F1 70
-#define HONEY_KEY_F2 71
-#define HONEY_KEY_F3 72
-#define HONEY_KEY_F4 73
-#define HONEY_KEY_F5 74
-#define HONEY_KEY_F6 75
-#define HONEY_KEY_F7 76
-#define HONEY_KEY_F8 77
-#define HONEY_KEY_F9 78
-#define HONEY_KEY_F10 79
-#define HONEY_KEY_F11 80
-#define HONEY_KEY_F12 81
-#define HONEY_KEY_F13 82
-#define HONEY_KEY_F14 83
-#define HONEY_KEY_F15 84
-#define HONEY_KEY_F16 85
-#define HONEY_KEY_F17 86
-#define HONEY_KEY_F18 87
-#define HONEY_KEY_F19 88
-#define HONEY_KEY_F20 89
-#define HONEY_KEY_F21 90
-#define HONEY_KEY_F22 91
-#define HONEY_KEY_F23 92
-#define HONEY_KEY_F24 93
-#define HONEY_KEY_F25 94
-#define HONEY_KEY_KP_0 95
-#define HONEY_KEY_KP_1 96
-#define HONEY_KEY_KP_2 97
-#define HONEY_KEY_KP_3 98
-#define HONEY_KEY_KP_4 99
-#define HONEY_KEY_KP_5 100
-#define HONEY_KEY_KP_6 101
-#define HONEY_KEY_KP_7 102
-#define HONEY_KEY_KP_8 103
-#define HONEY_KEY_KP_9 104
-#define HONEY_KEY_KP_DECIMAL 105
-#define HONEY_KEY_KP_DIVIDE 106
-#define HONEY_KEY_KP_MULTIPLY 107
-#define HONEY_KEY_KP_SUBTRACT 108
-#define HONEY_KEY_KP_ADD 109
-#define HONEY_KEY_KP_ENTER 110
-#define HONEY_KEY_KP_EQUAL 111
-#define HONEY_KEY_LEFT_SHIFT 112
-#define HONEY_KEY_LEFT_CONTROL 113
-#define HONEY_KEY_LEFT_ALT 114
-#define HONEY_KEY_LEFT_SUPER 115
-#define HONEY_KEY_RIGHT_SHIFT 116
-#define HONEY_KEY_RIGHT_CONTROL 117
-#define HONEY_KEY_RIGHT_ALT 118
-#define HONEY_KEY_RIGHT_SUPER 119
-#define HONEY_KEY_MENU 120
-
-#define HONEY_N_KEYS 121
-
-#define HONEY_KEY_PRESS GLFW_PRESS
-#define HONEY_KEY_RELEASE GLFW_RELEASE
-
-#define HONEY_MOUSE_MODE_NORMAL GLFW_CURSOR_NORMAL
-#define HONEY_MOUSE_MODE_HIDDEN GLFW_CURSOR_HIDDEN
-#define HONEY_MOUSE_MODE_DISABLED GLFW_CURSOR_DISABLED
-
-unsigned int honey_key_states[HONEY_N_KEYS];
-static int honey_key_callbacks[HONEY_N_KEYS];
-static int honey_key_callbacks_data[HONEY_N_KEYS];
-
-extern int honey_mouse_movement_callback_ref;
-extern int honey_mouse_movement_callback_data_ref;
-
-/** @brief Initializes Honey's internal keyboard states.
- * 
- * This function is called by honey_setup, so you shouldn't need
- * to manually call it in most cases.
- */
-void honey_setup_keyboard();
-
-/* @brief Place a lua table containing the enum values for GLFW keys on the stack. 
- * 
- * @param L The lua state to place the table on the top of the stack.
- *
- * @returns Nothing.
- */
-void honey_setup_input(lua_State* L);
-
-/** @brief Check if a key is down.
- *
- * This function accepts a single integer as input and returns TRUE if the integer
- * refers to a valid key and is pressed down, and false otherwise.
- *
- * @param[in] L The lua state.
- * 
- * @return 1 on success and 0 on failure.
- */
-int honey_key_down(lua_State* L);
-
-/** @brief Bind a callback to a key.
- *
- * The callback must have signature (void*, int), where the first argument is supplied by the 
- * void* supplied with this function, and the int is one of HONEY_KEY_PRESS or HONEY_KEY_RELEASE,
- * depending on the action that triggered the callback.
- *
- * @param[in] key The key to bind the callback to.
- * @param[in] callback The callback function to bind.
- * @param[in] data Data to pass to the callback function upon triggering.
- */
-int honey_key_bind(lua_State* L);
-
-/** @brief Unbind a key callback.
- *
- * THIS FUNCTION DOES NOT FREE MEMORY! If you allocated any, be sure to free it yourself!
- *
- * @param[in] key The key to unbind a callback from.
- */
-int honey_key_unbind(lua_State* L);
-
-/** @brief Unbind all key callbacks.
- *
- * THIS FUNCTION DOES NOT FREE MEMORY! If you allocated any, be sure to free it yourself!
- */
-int honey_key_unbind_all(lua_State* L);
-
-/** @brief Set the cursor mode.
- *
- * @param[in] mode The mouse mode (from honey.input.mouse.mode) to use.
- *
- * @returns Nothing.
- */
-int honey_mouse_set_mode(lua_State* L);
-
-/** Bind a callback to mouse movement.
- *
- * The callback should be of the form cb(xpos, ypos, data),
- * where xpos and ypos are the coordinates of the mouse relative to the
- * upper left corner of the window, and data is the data parameter passed
- * to this function.
- *
- * @param[in] callback A callback as described above.
- * @param[in] data Auxilliary data to pass to the callback.
- *
- * @returns Nothing.
- */
-int honey_mouse_movement_bind(lua_State* L);
-
-/** Unbind any callback that may be attached to mouse movement.
- *
- * @returns Nothing.
- */
-int honey_mouse_movement_unbind(lua_State* L);
-
-#endif