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