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