From a00e095e762b56ffcfe9d5fc5ef7e4c597df765d Mon Sep 17 00:00:00 2001 From: hgn Date: Sun, 6 Nov 2022 18:51:13 +0000 Subject: [PATCH] better input --- src/vg/vg_input.h | 476 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 369 insertions(+), 107 deletions(-) diff --git a/src/vg/vg_input.h b/src/vg/vg_input.h index f7df751..19e1f36 100644 --- a/src/vg/vg_input.h +++ b/src/vg/vg_input.h @@ -22,119 +22,409 @@ enum vg_button_state k_button_state_none = 0 }; -/* TODO: Fix this... */ -enum EInputMode -{ - k_EInputMode_pc, - k_EInputMode_gamepad -} -vg_input_mode; - -VG_STATIC struct axis_binding +VG_STATIC struct input_binding { const char *name; - union - { - int positive; - int bind; - int axis; - }; - int negative; - - float value; + + enum input_type + { + k_input_type_button, + k_input_type_axis, + k_input_type_axis_norm, + + k_input_type_unknown, + k_input_type_keyboard_key, + k_input_type_gamepad_axis, + k_input_type_gamepad_button + } + type; + + union + { + struct input_axis + { + u32 gamepad_axis, + keyboard_positive, + keyboard_negative; + + float value; + } + axis; + + struct + { + u32 gamepad_id, keyboard_id; + int value, prev; + } + button; + }; + + int save_this; } -vg_axis_binds[]; +vg_named_inputs[ 32 ]; +VG_STATIC u32 vg_named_input_count = 0; -VG_STATIC struct button_binding +VG_STATIC struct input_binding *vg_create_named_input( const char *name, + enum input_type type ) { - const char *name; - int bind; - - int value; int prev; + struct input_binding *bind = &vg_named_inputs[ vg_named_input_count ++ ]; + memset( bind, 0, sizeof(struct input_binding) ); + + bind->name = name; + bind->save_this = 0; + bind->type = type; + + return bind; } -vg_button_binds[], -vg_controller_binds[]; -#include "vg_config.h" +VG_STATIC struct input_binding *vg_get_named_input( const char *name ) +{ + for( u32 i=0; iname, name ) ) + return bind; + } -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wreturn-type" + return NULL; +} -VG_STATIC float vg_get_axis( const char *axis ) +struct input_en { - for( int i = 0; i < vg_list_size( vg_axis_binds ); i ++ ) - if( !strcmp( axis, vg_axis_binds[i].name ) ) - return vg_axis_binds[i].value; + enum input_type type; + + const char *alias; + int id; } +vg_all_bindable_inputs[] = +{ + {k_input_type_keyboard_key, "space", GLFW_KEY_SPACE}, + {k_input_type_keyboard_key, ";", GLFW_KEY_SEMICOLON}, + {k_input_type_keyboard_key, "-", GLFW_KEY_MINUS}, + {k_input_type_keyboard_key, ".", GLFW_KEY_PERIOD}, + {k_input_type_keyboard_key, ",", GLFW_KEY_COMMA}, + {k_input_type_keyboard_key, "=", GLFW_KEY_EQUAL}, + {k_input_type_keyboard_key, "[", GLFW_KEY_LEFT_BRACKET}, + {k_input_type_keyboard_key, "]", GLFW_KEY_RIGHT_BRACKET}, + {k_input_type_keyboard_key, "left", GLFW_KEY_LEFT}, + {k_input_type_keyboard_key, "right", GLFW_KEY_RIGHT}, + {k_input_type_keyboard_key, "up", GLFW_KEY_UP}, + {k_input_type_keyboard_key, "down", GLFW_KEY_DOWN}, + {k_input_type_keyboard_key, "shift", GLFW_KEY_LEFT_SHIFT}, + {k_input_type_keyboard_key, "control", GLFW_KEY_LEFT_CONTROL}, + + {k_input_type_gamepad_axis, "gp-lt", GLFW_GAMEPAD_AXIS_LEFT_TRIGGER}, + {k_input_type_gamepad_axis, "gp-rt", GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER}, + {k_input_type_gamepad_axis, "gp-ls-h", GLFW_GAMEPAD_AXIS_LEFT_X}, + {k_input_type_gamepad_axis, "gp-ls-v", GLFW_GAMEPAD_AXIS_LEFT_Y}, + {k_input_type_gamepad_axis, "gp-rs-h", GLFW_GAMEPAD_AXIS_RIGHT_X}, + {k_input_type_gamepad_axis, "gp-rs-v", GLFW_GAMEPAD_AXIS_RIGHT_Y}, + + {k_input_type_gamepad_button, "gp-a", GLFW_GAMEPAD_BUTTON_A}, + {k_input_type_gamepad_button, "gp-b", GLFW_GAMEPAD_BUTTON_B}, + {k_input_type_gamepad_button, "gp-x", GLFW_GAMEPAD_BUTTON_X}, + {k_input_type_gamepad_button, "gp-y", GLFW_GAMEPAD_BUTTON_Y}, + {k_input_type_gamepad_button, "gp-rb", GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER}, + {k_input_type_gamepad_button, "gp-lb", GLFW_GAMEPAD_BUTTON_LEFT_BUMPER}, + {k_input_type_gamepad_button, "gp-rs", GLFW_GAMEPAD_BUTTON_RIGHT_THUMB}, + {k_input_type_gamepad_button, "gp-ls", GLFW_GAMEPAD_BUTTON_LEFT_THUMB}, + {k_input_type_gamepad_button, "gp-dpad-down", GLFW_GAMEPAD_BUTTON_DPAD_DOWN}, + {k_input_type_gamepad_button, "gp-dpad-left", GLFW_GAMEPAD_BUTTON_DPAD_LEFT}, + {k_input_type_gamepad_button, "gp-dpad-right", GLFW_GAMEPAD_BUTTON_DPAD_RIGHT}, + {k_input_type_gamepad_button, "gp-dpad-up", GLFW_GAMEPAD_BUTTON_DPAD_UP} +}; -VG_STATIC struct button_binding *vg_get_button_ptr( const char *button ) +VG_STATIC const char *vg_input_to_str( u32 input, enum input_type input_type ) { - for( int i=0; i= GLFW_KEY_A) && (input <= GLFW_KEY_Z) ) + { + return &"a\0b\0c\0d\0e\0f\0g\0h\0i\0j\0k\0l\0m\0n\0o\0p\0" + "q\0r\0s\0t\0u\0v\0w\0x\0y\0z\0"[(input-GLFW_KEY_A)*2]; + } + + if( (input >= GLFW_KEY_0) && (input <= GLFW_KEY_9) ) + { + return &"0\0" "1\0" "2\0" "3\0" "4\0" + "5\0" "6\0" "7\0" "8\0" "9\0"[(input-GLFW_KEY_0)*2]; + } + } + + for( int i=0; itype == input_type) && (desc->id == input) ) + return desc->alias; + } + return NULL; } -VG_STATIC struct button_binding *vg_get_button_ptr_c( const char *button ) +VG_STATIC enum input_type vg_str_to_input( const char *str, u32 *input ) { - for( int i=0; i= (u8)'a') && (uch <= (u8)'z') ) + { + *input = GLFW_KEY_A + (uch-(u8)'a'); + return k_input_type_keyboard_key; + } + + if( (uch >= (u8)'0') && (uch <= (u8)'9') ) + { + *input = GLFW_KEY_0 + (uch-(u8)'0'); + return k_input_type_keyboard_key; + } + } + + for( int i=0; ialias, str ) ) + { + *input = desc->id; + return desc->type; + } + } + + *input = -1; + return k_input_type_unknown; } -#pragma GCC diagnostic pop +VG_STATIC void vg_print_binding_info( struct input_binding *bind ) +{ + vg_info( " name: %s\n", bind->name ); + vg_info( " type: %s\n", (const char *[]){"button","axis"}[ bind->type ] ); + vg_info( " save this? %d\n", bind->save_this ); + + if( (bind->type == k_input_type_axis) || + (bind->type == k_input_type_axis_norm) ) + { + vg_info( " gamepad_axis: %s\n", + vg_input_to_str(bind->axis.gamepad_axis, k_input_type_gamepad_axis)); -VG_STATIC int vg_console_enabled(void); + vg_info( " keyboard_positive: %s\n", + vg_input_to_str(bind->axis.keyboard_positive, + k_input_type_keyboard_key )); -VG_STATIC void vg_get_button_states( const char *name, int *cur, int *prev ) + vg_info( " keyboard_negative: %s\n", + vg_input_to_str(bind->axis.keyboard_negative, + k_input_type_keyboard_key )); + } + else + { + vg_info( " gamepad_id: %s\n", + vg_input_to_str(bind->button.gamepad_id, k_input_type_gamepad_button)); + vg_info( " keyboard_id: %s\n", + vg_input_to_str(bind->button.keyboard_id, + k_input_type_keyboard_key)); + } +} + +/* + * bind x jump + * bind a -horizontal + * bind d +horizontal + */ + +VG_STATIC int vg_rebind_input_cmd( int argc, const char *argv[] ) { - struct button_binding *bind = vg_get_button_ptr( name ), - *bindc = vg_get_button_ptr_c( name ); - - *cur = 0; *prev = 0; + if( argc == 0 ) + { + vg_info( "Usage: bind jump x\n" ); + vg_info( " bind -steerh j\n" ); + vg_info( " bind steerh gp-ls-h\n" ); + return 0; + } + + if( strlen(argv[0]) == 0 ) + return 0; + + int axis_mod = 0; + if( (argv[0][0] == '-') || (argv[0][0] == '+') ) + axis_mod = 1; + + struct input_binding *bind = vg_get_named_input( argv[0]+axis_mod ); - if( bind ) + if( !bind ) { - *cur |= bind->value; - *prev |= bind->prev; + vg_error( "There is no named input called %s\n", argv[0]+axis_mod ); + return 0; } - if( bindc ) + if( argc == 1 ) { - *cur |= bindc->value; - *prev |= bindc->prev; + vg_print_binding_info( bind ); + return 0; + } + + if( argc == 2 ) + { + u32 id; + enum input_type type = vg_str_to_input( argv[1], &id ); + + if( bind->type == k_input_type_button ) + { + if( axis_mod ) + { + vg_error( "Cannot use axis modifiers on button input!\n" ); + return 0; + } + + if( type == k_input_type_keyboard_key ) + bind->button.keyboard_id = id; + else if( type == k_input_type_gamepad_button ) + bind->button.gamepad_id = id; + else + { + vg_error( "Unknown button or key '%s'\n", argv[1] ); + return 0; + } + } + else if( (bind->type == k_input_type_axis ) || + (bind->type == k_input_type_axis_norm)) + { + if( axis_mod ) + { + if( type == k_input_type_keyboard_key ) + { + if( argv[0][0] == '+' ) + bind->axis.keyboard_positive = id; + else + bind->axis.keyboard_negative = id; + } + else + { + vg_error( "You can only bind keyboard keys to +- axises\n" ); + return 0; + } + } + else + { + if( type == k_input_type_gamepad_axis ) + bind->axis.gamepad_axis = id; + else + { + vg_error( "You can only bind gamepad axises to this\n" ); + return 0; + } + } + } } + + return 0; } -VG_STATIC int vg_get_button( const char *button ) +VG_STATIC void vg_input_update( u32 num, struct input_binding *binds ) { - int cur, prev; - vg_get_button_states( button, &cur, &prev ); + for( i32 i=0; itype == k_input_type_button ) + { + bind->button.prev = bind->button.value; + bind->button.value = 0; + + if( bind->button.gamepad_id != -1 ) + bind->button.value |= vg.gamepad.buttons[ bind->button.gamepad_id ]; + + if( bind->button.keyboard_id != -1 ) + bind->button.value |= glfwGetKey( vg.window, + bind->button.keyboard_id ); + } + else if( bind->type == k_input_type_axis ) + { + float keyboard_value = 0.0f, + gamepad_value = 0.0f; + + if( bind->axis.keyboard_positive != -1 ) + if( glfwGetKey( vg.window, bind->axis.keyboard_positive ) ) + keyboard_value += 1.0f; + + if( bind->axis.keyboard_negative != -1 ) + if( glfwGetKey( vg.window, bind->axis.keyboard_negative ) ) + keyboard_value -= 1.0f; + + if( bind->axis.gamepad_axis != -1 ) + gamepad_value = vg.gamepad.axes[ bind->axis.gamepad_axis ]; + + if( fabsf(gamepad_value) <= 0.01f ) + gamepad_value = 0.0f; - return cur && !vg_console_enabled(); + if( fabsf(keyboard_value) > fabsf(gamepad_value) ) + bind->axis.value = keyboard_value; + else + bind->axis.value = gamepad_value; + } + else if( bind->type == k_input_type_axis_norm ) + { + float value = -1.0f; + if( bind->axis.keyboard_positive != -1 ) + if( glfwGetKey( vg.window, bind->axis.keyboard_positive )) + value = 1.0f; + + if( bind->axis.gamepad_axis != -1 ) + value = vg_maxf( value, vg.gamepad.axes[bind->axis.gamepad_axis] ); + + bind->axis.value = value * 0.5f + 0.5f; + } + } } -VG_STATIC int vg_get_button_down( const char *button ) +VG_STATIC int vg_input_button_down( struct input_binding *bind ) { - if( vg.engine_stage == k_engine_stage_update_fixed ) - vg_fatal_exit_loop( "Cannot use that here\n" ); + if( bind->button.value && !bind->button.prev ) + return 1; + return 0; +} - int cur, prev; - vg_get_button_states( button, &cur, &prev ); +VG_STATIC float vg_get_axis( const char *axis ) +{ + return 0.0f; +} + +VG_STATIC int vg_console_enabled(void); - return cur & (cur ^ prev) && !vg_console_enabled(); +VG_STATIC void vg_get_button_states( const char *name, int *cur, int *prev ) +{ } -VG_STATIC int vg_get_button_up( const char *button ) +VG_STATIC int vg_get_button( const char *button ) { - if( vg.engine_stage == k_engine_stage_update_fixed ) - vg_fatal_exit_loop( "Cannot use that here\n" ); + return 0; +} - int cur, prev; - vg_get_button_states( button, &cur, &prev ); +VG_STATIC int vg_get_button_down( const char *button ) +{ + return 0; +} - return prev & (cur ^ prev) && !vg_console_enabled(); +VG_STATIC int vg_get_button_up( const char *button ) +{ + return 0; } VG_STATIC enum vg_button_state vg_get_button_state( const char *button ) @@ -145,21 +435,6 @@ VG_STATIC enum vg_button_state vg_get_button_state( const char *button ) return k_button_state_none; } -VG_STATIC int key_is_keyboard( int const id ) -{ - vg_static_assert( GLFW_MOUSE_BUTTON_LAST < GLFW_KEY_SPACE, - "GLFW: Mouse has too many buttons" ); - return id > GLFW_MOUSE_BUTTON_LAST; -} - -int get_button_cross_device( int const id ) -{ - if( key_is_keyboard( id ) ) - return glfwGetKey( vg.window, id ); - else - return glfwGetMouseButton( vg.window, id ) == GLFW_PRESS; -} - void vg_update_inputs(void) { if( !glfwGetGamepadState( GLFW_JOYSTICK_1, &vg.gamepad) ) @@ -169,33 +444,20 @@ void vg_update_inputs(void) vg.gamepad.axes[ GLFW_GAMEPAD_AXIS_LEFT_TRIGGER ] = -1.0f; } - /* Update button inputs */ - for( int i = 0; i < vg_list_size( vg_button_binds ); i ++ ) - { - struct button_binding *binding = vg_button_binds + i; - binding->prev = binding->value; - binding->value = get_button_cross_device( binding->bind ); - } - - for( int i=0; iprev = binding->value; - binding->value = vg.gamepad.buttons[ binding->bind ]; - } - - /* Update axis inputs */ - for( int i = 0; i < vg_list_size( vg_axis_binds ); i ++ ) - { - struct axis_binding *binding = vg_axis_binds + i; - binding->value = vg.gamepad.axes[ binding->bind ]; - } + /* update all inputs */ + vg_input_update( vg_named_input_count, vg_named_inputs ); } VG_STATIC void vg_gamepad_init(void) { vg_acquire_thread_sync(); + vg_function_push( (struct vg_cmd) + { + .name = "bind", + .function = vg_rebind_input_cmd + }); + for( int id=0; id<=GLFW_JOYSTICK_LAST; id ++ ) { if( glfwJoystickPresent( id ) ) -- 2.25.1