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