input.h

   1 #ifndef INPUT_H
   2 #define INPUT_H
   3
   4 #define VG_GAME
   5 #include "vg/vg.h"
   6 #include "vg/vg_platform.h"
   7 #include "vg/vg_console.h"
   8 #include "vg/vg_input.h"
   9 #include "vg/vg_m.h"
  10 #include "font.h"
  11
  12 enum sr_bind{
  13    k_srbind_jump = 0,
  14    k_srbind_push,
  15    k_srbind_trick0,
  16    k_srbind_trick1,
  17    k_srbind_trick2,
  18    k_srbind_sit,
  19    k_srbind_use,
  20    k_srbind_reset,
  21    k_srbind_camera,
  22    k_srbind_mleft,
  23    k_srbind_mright,
  24    k_srbind_mup,
  25    k_srbind_mdown,
  26    k_srbind_mback,
  27    k_srbind_maccept,
  28    k_srbind_mopen,
  29    k_srbind_replay_play,
  30    k_srbind_replay_freecam,
  31    k_srbind_replay_resume,
  32    k_srbind_world_left,
  33    k_srbind_world_right,
  34    k_srbind_home,
  35    k_srbind_lobby,
  36    k_srbind_chat,
  37    k_srbind_max,
  38 };
  39
  40 enum sr_joystick{
  41    k_srjoystick_steer = 0,
  42    k_srjoystick_grab,
  43    k_srjoystick_look,
  44    k_srjoystick_max
  45 };
  46
  47 enum sr_axis{
  48    k_sraxis_grab = 0,
  49    k_sraxis_mbrowse_h,
  50    k_sraxis_mbrowse_v,
  51    k_sraxis_replay_h,
  52    k_sraxis_mworld_h,
  53
  54    k_sraxis_max
  55 };
  56
  57
  58 #define INPUT_BASIC( KB, JS ) \
  59    (vg_input_op[]){vg_keyboard, KB, vg_joy_button, JS, vg_end}
  60
  61 static vg_input_op *input_button_list[] = {
  62 [k_srbind_jump]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
  63 [k_srbind_push]  = INPUT_BASIC( SDLK_w, SDL_CONTROLLER_BUTTON_B ),
  64 [k_srbind_trick0] = (vg_input_op[]){
  65    vg_mouse, SDL_BUTTON_LEFT,
  66    vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
  67 },
  68 [k_srbind_trick1] = (vg_input_op[]){
  69    vg_mouse, SDL_BUTTON_RIGHT,
  70    vg_joy_button, SDL_CONTROLLER_BUTTON_B, vg_end
  71 },
  72 [k_srbind_trick2] = (vg_input_op[]){
  73    vg_mode_mul, vg_mouse, SDL_BUTTON_LEFT, vg_mouse, SDL_BUTTON_RIGHT,
  74    vg_mode_absmax, vg_joy_button, SDL_CONTROLLER_BUTTON_X, vg_end
  75 },
  76 [k_srbind_use]   = INPUT_BASIC( SDLK_e, SDL_CONTROLLER_BUTTON_Y ),
  77 [k_srbind_reset] = INPUT_BASIC( SDLK_r, SDL_CONTROLLER_BUTTON_LEFTSHOULDER ),
  78 [k_srbind_camera]= INPUT_BASIC( SDLK_c, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ),
  79 [k_srbind_mleft] = INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  80 [k_srbind_mright]= INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
  81 [k_srbind_world_left] =
  82                    INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  83 [k_srbind_world_right] =
  84                    INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
  85 [k_srbind_home]  = INPUT_BASIC( SDLK_h, SDL_CONTROLLER_BUTTON_Y ),
  86 [k_srbind_mup]   = INPUT_BASIC( SDLK_UP, SDL_CONTROLLER_BUTTON_DPAD_UP ),
  87 [k_srbind_mdown] = INPUT_BASIC( SDLK_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN ),
  88 [k_srbind_mback] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_B ),
  89 [k_srbind_mopen] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_START ),
  90 [k_srbind_maccept] = (vg_input_op[]){
  91    vg_keyboard, SDLK_e, vg_keyboard, SDLK_RETURN, vg_keyboard, SDLK_RETURN2,
  92    vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
  93 },
  94 [k_srbind_replay_play]    = INPUT_BASIC( SDLK_g, SDL_CONTROLLER_BUTTON_X ),
  95 [k_srbind_replay_resume]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
  96 [k_srbind_replay_freecam] = INPUT_BASIC( SDLK_f, SDL_CONTROLLER_BUTTON_Y ),
  97 [k_srbind_sit]   = INPUT_BASIC( SDLK_z, SDL_CONTROLLER_BUTTON_B ),
  98 [k_srbind_lobby] = INPUT_BASIC( SDLK_TAB, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  99 [k_srbind_chat ] = (vg_input_op[]){ vg_keyboard, SDLK_y, vg_end },
 100 [k_srbind_max]=NULL
 101 };
 102
 103 static vg_input_op *input_axis_list[] = {
 104 [k_sraxis_grab] = (vg_input_op[]){
 105    vg_keyboard, SDLK_LSHIFT,
 106    vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, vg_end
 107 },
 108 [k_sraxis_mbrowse_h] = (vg_input_op[]){
 109    vg_mode_add, vg_keyboard, SDLK_RIGHT,
 110    vg_mode_sub, vg_keyboard, SDLK_LEFT,
 111    vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTX,
 112    vg_end
 113 },
 114 [k_sraxis_mbrowse_v] = (vg_input_op[]){
 115    vg_mode_add, vg_keyboard, SDLK_UP,
 116    vg_mode_sub, vg_keyboard, SDLK_DOWN,
 117    vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTY,
 118    vg_end
 119 },
 120 [k_sraxis_replay_h] = (vg_input_op[]){
 121    vg_mode_add, vg_keyboard, SDLK_e,
 122    vg_mode_sub, vg_keyboard, SDLK_q,
 123    vg_mode_add, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
 124    vg_mode_sub, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERLEFT,
 125    vg_end
 126 },
 127 [k_sraxis_max]=NULL
 128 };
 129
 130 static vg_input_op *input_joy_list[] = {
 131 [k_srjoystick_steer] = (vg_input_op[]){
 132    vg_index, 0, vg_mode_add, vg_keyboard, SDLK_d,
 133                 vg_mode_sub, vg_keyboard, SDLK_a,
 134                 vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTX,
 135    vg_index, 1, vg_mode_add, vg_keyboard, SDLK_s,
 136                 vg_mode_sub, vg_keyboard, SDLK_w,
 137                 vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTY,
 138    vg_end
 139 },
 140 [k_srjoystick_grab] = (vg_input_op[]){
 141    vg_index, 0, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTX,
 142    vg_index, 1, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTY,
 143    vg_end
 144 },
 145 [k_srjoystick_look] = (vg_input_op[]){
 146    vg_index, 0, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTX,
 147    vg_index, 1, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTY,
 148    vg_end
 149 },
 150 [k_srjoystick_max]=NULL
 151 };
 152
 153 struct {
 154    float axis_states[ k_sraxis_max ][2];
 155    v2f joystick_states[ k_srjoystick_max ][2];
 156    u8 button_states[ k_srbind_max ][2];
 157
 158    enum input_state {
 159       k_input_state_enabled,
 160       k_input_state_resume,
 161       k_input_state_pause
 162    }
 163    state;
 164 }
 165 static srinput;
 166
 167 static const char *controller_glyphs[ SDL_CONTROLLER_BUTTON_MAX ][2] =
 168 {                                        /* xbox/generic  playstation */
 169    [ SDL_CONTROLLER_BUTTON_A ]            = { "\x1e\x85","\x1e\x82" },
 170    [ SDL_CONTROLLER_BUTTON_B ]            = { "\x1e\x86","\x1e\x81" },
 171    [ SDL_CONTROLLER_BUTTON_X ]            = { "\x1e\x83","\x1e\x7f" },
 172    [ SDL_CONTROLLER_BUTTON_Y ]            = { "\x1e\x84","\x1e\x80" },
 173    [ SDL_CONTROLLER_BUTTON_LEFTSTICK ]    = { "\x87",    "\x87" },
 174    [ SDL_CONTROLLER_BUTTON_RIGHTSTICK ]   = { "\x8b",    "\x8b" },
 175    [ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] = { "\x91",    "\x91" },
 176    [ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ]= { "\x92",    "\x92" },
 177    [ SDL_CONTROLLER_BUTTON_DPAD_LEFT ]    = { "\x1e\x93","\x1e\x93" },
 178    [ SDL_CONTROLLER_BUTTON_DPAD_UP ]      = { "\x1e\x94","\x1e\x94" },
 179    [ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ]   = { "\x1e\x95","\x1e\x95" },
 180    [ SDL_CONTROLLER_BUTTON_DPAD_DOWN ]    = { "\x1e\x96","\x1e\x96" },
 181    [ SDL_CONTROLLER_BUTTON_GUIDE ]        = { "\x91",    "\x91" },
 182 };
 183
 184 static const char *controller_glyph( u32 sdl_index ){
 185    if( vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS3 ||
 186        vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS4 ||
 187        vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS5 )
 188    {
 189       return controller_glyphs[ sdl_index ][ 1 ];
 190    }
 191    else if( vg_input.display_input_type ==
 192                SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO ||
 193             vg_input.display_input_type ==
 194                SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT ||
 195             vg_input.display_input_type ==
 196                SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_PAIR ||
 197             vg_input.display_input_type ==
 198                SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT )
 199    {
 200       return NULL;
 201    }
 202    else
 203       return controller_glyphs[ sdl_index ][ 0 ];
 204 }
 205
 206 #define KEYBOARD_GLYPH( X ) "\x1f" X "  "
 207
 208 static const char *button_display_string( enum sr_bind button )
 209 {
 210    const char *controller_table[ k_srbind_max ] = {
 211     [k_srbind_jump]   = controller_glyph( SDL_CONTROLLER_BUTTON_A ),
 212     [k_srbind_push]   = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
 213     [k_srbind_trick0] = controller_glyph( SDL_CONTROLLER_BUTTON_A ),
 214     [k_srbind_trick1] = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
 215     [k_srbind_trick2] = controller_glyph( SDL_CONTROLLER_BUTTON_X ),
 216     [k_srbind_use]    = controller_glyph( SDL_CONTROLLER_BUTTON_Y ),
 217     [k_srbind_reset]  = controller_glyph( SDL_CONTROLLER_BUTTON_LEFTSHOULDER ),
 218     [k_srbind_camera] = controller_glyph( SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ),
 219     [k_srbind_mleft]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
 220     [k_srbind_mright] = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
 221     [k_srbind_world_left]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
 222     [k_srbind_world_right] = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
 223     [k_srbind_home] = controller_glyph( SDL_CONTROLLER_BUTTON_Y ),
 224     [k_srbind_mup]    = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_UP ),
 225     [k_srbind_mdown]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_DOWN ),
 226     [k_srbind_mback]  = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
 227     [k_srbind_maccept]= controller_glyph( SDL_CONTROLLER_BUTTON_A ),
 228     [k_srbind_mopen]  = controller_glyph( SDL_CONTROLLER_BUTTON_GUIDE ),
 229 [k_srbind_replay_play]= controller_glyph( SDL_CONTROLLER_BUTTON_X ),
 230 [k_srbind_replay_freecam]=controller_glyph(SDL_CONTROLLER_BUTTON_Y ),
 231 [k_srbind_replay_resume]=controller_glyph( SDL_CONTROLLER_BUTTON_A ),
 232    [k_srbind_sit]     = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
 233     [k_srbind_lobby]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
 234     [k_srbind_chat]   = ""
 235    };
 236
 237    const char *keyboard_table[ k_srbind_max ] = {
 238     [k_srbind_jump]   = "\xa1",
 239     [k_srbind_push]   = KEYBOARD_GLYPH( "W" ),
 240     [k_srbind_trick0] = "\x99",
 241     [k_srbind_trick1] = "\x9a",
 242     [k_srbind_trick2] = "\x9b",
 243     [k_srbind_use]    = KEYBOARD_GLYPH( "E" ),
 244     [k_srbind_reset]  = KEYBOARD_GLYPH( "R" ),
 245     [k_srbind_camera] = KEYBOARD_GLYPH( "C" ),
 246     [k_srbind_mleft]  = KEYBOARD_GLYPH( "\x93" ),
 247     [k_srbind_mright] = KEYBOARD_GLYPH( "\x95" ),
 248     [k_srbind_world_left]  = KEYBOARD_GLYPH( "\x93" ),
 249     [k_srbind_world_right] = KEYBOARD_GLYPH( "\x95" ),
 250     [k_srbind_home] = KEYBOARD_GLYPH( "H" ),
 251     [k_srbind_mup]    = KEYBOARD_GLYPH( "\x94" ),
 252     [k_srbind_mdown]  = KEYBOARD_GLYPH( "\x96" ),
 253     [k_srbind_mback]  = "\xa3",
 254     [k_srbind_maccept]= "\xa2",
 255     [k_srbind_mopen]  = "\xa3" ,
 256 [k_srbind_replay_play]= KEYBOARD_GLYPH( "G" ),
 257 [k_srbind_replay_freecam] = KEYBOARD_GLYPH( "F" ),
 258 [k_srbind_replay_resume]= "\xa1",
 259     [k_srbind_sit]    = KEYBOARD_GLYPH( "Z" ),
 260     [k_srbind_lobby] = KEYBOARD_GLYPH( "" ), // FIXME: what is tab?
 261     [k_srbind_chat] = KEYBOARD_GLYPH( "Y" )
 262    };
 263
 264    if( vg_input.display_input_method == k_input_method_controller )
 265       return controller_table[ button ];
 266    else
 267       return keyboard_table[ button ];
 268 }
 269
 270 static const char *axis_display_string( enum sr_axis axis )
 271 {
 272    const char *controller_table[ k_sraxis_max ] = {
 273     [k_sraxis_grab]      = "\x90",
 274     [k_sraxis_mbrowse_h] = "\x88",
 275     [k_sraxis_mbrowse_v] = "\x89",
 276     [k_sraxis_replay_h]  = "\x8f\x90",
 277     [k_sraxis_mworld_h]  = "\x93\x95"
 278    };
 279
 280    const char *keyboard_table[ k_sraxis_max ] = {
 281     [k_sraxis_grab]      = "\x9e",
 282     [k_sraxis_mbrowse_h] = KEYBOARD_GLYPH("\x93")KEYBOARD_GLYPH("\x95"),
 283     [k_sraxis_mbrowse_v] = KEYBOARD_GLYPH("\x96")KEYBOARD_GLYPH("\x94"),
 284     [k_sraxis_replay_h]  = KEYBOARD_GLYPH("Q")KEYBOARD_GLYPH("E"),
 285     [k_sraxis_mworld_h] = KEYBOARD_GLYPH("\x93")KEYBOARD_GLYPH("\x95"),
 286    };
 287
 288    if( vg_input.display_input_method == k_input_method_controller )
 289       return controller_table[ axis ];
 290    else
 291       return keyboard_table[ axis ];
 292 }
 293
 294 static const char *joystick_display_string( enum sr_joystick joystick,
 295                                             u32 axis )
 296 {
 297    const char *controller_table[ k_srjoystick_max ][3] = {
 298     [k_srjoystick_steer] = {"\x88","\x89","\x8a"},
 299     [k_srjoystick_grab]  = {"\x8c","\x8d","\x8e"},
 300     [k_srjoystick_look]  = {"\x8c","\x8d","\x8e"}
 301    };
 302
 303    const char *keyboard_table[ k_srjoystick_max ][3] = {
 304     [k_srjoystick_steer] = {KEYBOARD_GLYPH("A")KEYBOARD_GLYPH("D"), /*h*/
 305                             KEYBOARD_GLYPH("W")KEYBOARD_GLYPH("S"), /*v*/
 306
 307                             KEYBOARD_GLYPH("A")KEYBOARD_GLYPH("D") /*hv*/
 308                             KEYBOARD_GLYPH("W")KEYBOARD_GLYPH("S"), },
 309     [k_srjoystick_grab]  = {"\xa4","\xa4","\xa4"},
 310     [k_srjoystick_look]  = {"\xa4","\xa4","\xa4"}
 311    };
 312
 313    if( vg_input.display_input_method == k_input_method_controller )
 314       return controller_table[ joystick ][axis];
 315    else  return keyboard_table[ joystick ][axis];
 316 }
 317
 318 static int input_filter_generic(void){
 319    if( srinput.state != k_input_state_enabled ||
 320        vg_ui.wants_mouse || vg_console.enabled )
 321       return 1;
 322    else
 323       return 0;
 324 }
 325
 326 static int buttons_filter_fixed(void){
 327    if( input_filter_generic() )
 328       return 1;
 329
 330    if( vg.engine_stage == k_engine_stage_update_fixed )
 331       if( vg.fixed_iterations > 0 )
 332          return 1;
 333
 334    return 0;
 335 }
 336
 337 /* Rising edge of button */
 338 static int button_down( enum sr_bind button ){
 339    if( buttons_filter_fixed() ) return 0;
 340
 341    if(  srinput.button_states[ button ][0] &&
 342        !srinput.button_states[ button ][1] )
 343       return 1;
 344    else
 345       return 0;
 346 }
 347
 348 /* Falling edge of button */
 349 static int button_up( enum sr_bind button ){
 350    if( buttons_filter_fixed() ) return 0;
 351
 352    if( !srinput.button_states[ button ][0] &&
 353         srinput.button_states[ button ][1] )
 354       return 1;
 355    else
 356       return 0;
 357 }
 358
 359 /* State of button */
 360 static int button_press( enum sr_bind button ){
 361    if( input_filter_generic() )
 362       return 0;
 363    return
 364       srinput.button_states[ button ][0];
 365 }
 366
 367 static void joystick_state( enum sr_joystick joystick, v2f state ){
 368    if( input_filter_generic() )
 369       v2_zero( state );
 370    else
 371       v2_copy( srinput.joystick_states[ joystick ][0], state );
 372 }
 373
 374 static float axis_state( enum sr_axis axis ){
 375    if( input_filter_generic() )
 376       return 0.0f;
 377    else
 378       return srinput.axis_states[axis][0];
 379 }
 380
 381 static void setbtn( enum sr_bind button, u8 value )
 382 {
 383    srinput.button_states[button][0] |= value;
 384 }
 385
 386 static void skaterift_preupdate_inputs(void){
 387    if( srinput.state == k_input_state_resume )
 388       srinput.state = k_input_state_enabled;
 389
 390    for( u32 i=0; i<k_srbind_max; i++ ){
 391       srinput.button_states[i][1] = srinput.button_states[i][0];
 392       srinput.button_states[i][0] = 0;
 393    }
 394
 395    for( u32 i=0; i<k_srjoystick_max; i++ ){
 396       v2_copy( srinput.joystick_states[i][0], srinput.joystick_states[i][1] );
 397       v2_zero( srinput.joystick_states[i][0] );
 398    }
 399
 400    for( u32 i=0; i<k_sraxis_max; i++ ){
 401       srinput.axis_states[i][1] = srinput.axis_states[i][0];
 402       srinput.axis_states[i][0] = 0.0f;
 403    }
 404
 405    u32 mouse = SDL_GetMouseState(NULL,NULL),
 406        mouse1= (mouse & SDL_BUTTON(SDL_BUTTON_LEFT))? 1: 0,
 407        mouse2= (mouse & SDL_BUTTON(SDL_BUTTON_RIGHT))? 1: 0;
 408
 409    for( int i=0; i<k_srbind_max; i++ ){
 410       vg_input_op *prog = input_button_list[i];
 411       if( prog ){
 412          vg_exec_input_program( k_vg_input_type_button_u8, prog,
 413                                 &srinput.button_states[i][0] );
 414       }
 415    }
 416
 417    for( int i=0; i<k_sraxis_max; i++ ){
 418       vg_input_op *prog = input_axis_list[i];
 419       if( prog ){
 420          vg_exec_input_program( k_vg_input_type_axis_f32, prog,
 421                                 &srinput.axis_states[i][0] );
 422       }
 423    }
 424
 425    for( int i=0; i<k_srjoystick_max; i++ ){
 426       vg_input_op *prog = input_joy_list[i];
 427       if( prog ){
 428          vg_exec_input_program( k_vg_input_type_joy_v2f, prog,
 429                                 srinput.joystick_states[i][0] );
 430       }
 431    }
 432 }
 433
 434 #endif /* INPUT_H */