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