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