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]   = KEYBOARD_GLYPH( "A" ),
 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 {
 162    const char *controller_table[ k_srjoystick_max ] = {
 163     [k_srjoystick_steer] = "\x88",
 164     [k_srjoystick_grab]  = "\x8e",
 165     [k_srjoystick_look]  = "\x8e"
 166    };
 167
 168    const char *keyboard_table[ k_srjoystick_max ] = {
 169     [k_srjoystick_steer] = KEYBOARD_GLYPH( "\x93" )KEYBOARD_GLYPH( "\x95" ),
 170     [k_srjoystick_grab]  = "\xa4",
 171     [k_srjoystick_look]  = "\xa4"
 172    };
 173
 174    if( vg_input.display_input_method == k_input_method_controller )
 175       return controller_table[ joystick ];
 176    else
 177       return keyboard_table[ joystick ];
 178 }
 179
 180 static int buttons_filter_fixed(void)
 181 {
 182    if( srinput.ignore_input_frames )
 183       return 1;
 184
 185    if( vg_console.enabled )
 186       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() )
 199       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() )
 212       return 0;
 213
 214    if( !srinput.button_states[ button ][0] &&
 215         srinput.button_states[ button ][1] )
 216       return 1;
 217    else
 218       return 0;
 219 }
 220
 221 /* State of button */
 222 static int button_press( enum sr_bind button )
 223 {
 224    if( vg_console.enabled )
 225       return 0;
 226
 227    return srinput.button_states[ button ][0];
 228 }
 229
 230 static void joystick_state( enum sr_joystick joystick, v2f state )
 231 {
 232    if( vg_console.enabled )
 233       v2_zero( state );
 234    else
 235       v2_copy( srinput.joystick_states[ joystick ][0], state );
 236 }
 237
 238 static float axis_state( enum sr_axis axis )
 239 {
 240    if( vg_console.enabled ) return 0.0f;
 241    else return srinput.axis_states[axis][0];
 242 }
 243
 244 static void setbtn( enum sr_bind button, u8 value )
 245 {
 246    srinput.button_states[button][0] |= value;
 247 }
 248
 249 static void skaterift_preupdate_inputs(void)
 250 {
 251    if( srinput.ignore_input_frames )
 252       srinput.ignore_input_frames --;
 253
 254    for( u32 i=0; i<k_srbind_max; i++ ){
 255       srinput.button_states[i][1] = srinput.button_states[i][0];
 256       srinput.button_states[i][0] = 0;
 257    }
 258
 259    for( u32 i=0; i<k_srjoystick_max; i++ ){
 260       v2_copy( srinput.joystick_states[i][0], srinput.joystick_states[i][1] );
 261       v2_zero( srinput.joystick_states[i][0] );
 262    }
 263
 264    for( u32 i=0; i<k_sraxis_max; i++ ){
 265       srinput.axis_states[i][1] = srinput.axis_states[i][0];
 266       srinput.axis_states[i][0] = 0.0f;
 267    }
 268
 269    u32 mouse = SDL_GetMouseState(NULL,NULL),
 270        mouse1= (mouse & SDL_BUTTON(SDL_BUTTON_LEFT))? 1: 0,
 271        mouse2= (mouse & SDL_BUTTON(SDL_BUTTON_RIGHT))? 1: 0;
 272
 273    /* button inputs
 274     * ------------------------------------- */
 275    setbtn( k_srbind_jump,    vg_getkey(SDLK_SPACE) );
 276    setbtn( k_srbind_push,    vg_getkey(SDLK_w) );
 277    setbtn( k_srbind_trick0,  mouse1 );
 278    setbtn( k_srbind_trick1,  mouse2 );
 279    setbtn( k_srbind_trick2,  mouse1 & mouse2 );
 280    setbtn( k_srbind_use,     vg_getkey(SDLK_e) );
 281    setbtn( k_srbind_reset,   vg_getkey(SDLK_r) );
 282    setbtn( k_srbind_camera,  vg_getkey(SDLK_c) );
 283    setbtn( k_srbind_mleft,   vg_getkey(SDLK_LEFT) );
 284    setbtn( k_srbind_mright,  vg_getkey(SDLK_RIGHT) );
 285    setbtn( k_srbind_mup,     vg_getkey(SDLK_UP) );
 286    setbtn( k_srbind_mdown,   vg_getkey(SDLK_DOWN) );
 287    setbtn( k_srbind_mback,   vg_getkey(SDLK_ESCAPE) );
 288    setbtn( k_srbind_mopen,   vg_getkey(SDLK_ESCAPE) );
 289    setbtn( k_srbind_maccept, vg_getkey(SDLK_e) );
 290    setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN));
 291    setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN2));
 292
 293    /* axis
 294     * --------------------------------------------*/
 295    srinput.axis_states[ k_sraxis_grab ][0] = vg_getkey( SDLK_LSHIFT );
 296
 297    if( vg_getkey( SDLK_d ) )
 298       srinput.joystick_states[k_srjoystick_steer][0][0] += 1.0f;
 299    if( vg_getkey( SDLK_a ) )
 300       srinput.joystick_states[k_srjoystick_steer][0][0] -= 1.0f;
 301    if( vg_getkey( SDLK_w ) )
 302       srinput.joystick_states[k_srjoystick_steer][0][1] -= 1.0f;
 303    if( vg_getkey( SDLK_s ) )
 304       srinput.joystick_states[k_srjoystick_steer][0][1] += 1.0f;
 305
 306    if( vg_getkey( SDLK_DOWN ) )
 307       srinput.axis_states[ k_sraxis_mbrowse_v ][0] -= 1.0f;
 308    if( vg_getkey( SDLK_UP ) )
 309       srinput.axis_states[ k_sraxis_mbrowse_v ][0] += 1.0f;
 310    if( vg_getkey( SDLK_LEFT ) )
 311       srinput.axis_states[ k_sraxis_mbrowse_h ][0] -= 1.0f;
 312    if( vg_getkey( SDLK_RIGHT ) )
 313       srinput.axis_states[ k_sraxis_mbrowse_h ][0] += 1.0f;
 314
 315    if( vg_input.active_controller_index != -1 ){
 316       struct vg_controller *controller =
 317          &vg_input.controllers[vg_input.active_controller_index];
 318
 319       u32 *buttons = controller->buttons;
 320       setbtn( k_srbind_jump,   buttons[ SDL_CONTROLLER_BUTTON_A ] );
 321       setbtn( k_srbind_push,   buttons[ SDL_CONTROLLER_BUTTON_B ] );
 322       setbtn( k_srbind_trick0, buttons[ SDL_CONTROLLER_BUTTON_A ] );
 323       setbtn( k_srbind_trick1, buttons[ SDL_CONTROLLER_BUTTON_B ] );
 324       setbtn( k_srbind_trick2, buttons[ SDL_CONTROLLER_BUTTON_X ] );
 325       setbtn( k_srbind_use,    buttons[ SDL_CONTROLLER_BUTTON_Y ] );
 326       setbtn( k_srbind_reset,  buttons[ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] );
 327       setbtn( k_srbind_camera, buttons[ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ] );
 328       setbtn( k_srbind_mleft,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] );
 329       setbtn( k_srbind_mright, buttons[ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ] );
 330       setbtn( k_srbind_mup,    buttons[ SDL_CONTROLLER_BUTTON_DPAD_UP ] );
 331       setbtn( k_srbind_mdown,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_DOWN ] );
 332       setbtn( k_srbind_mback,  buttons[ SDL_CONTROLLER_BUTTON_B ] );
 333       setbtn( k_srbind_maccept,buttons[ SDL_CONTROLLER_BUTTON_A ] );
 334       setbtn( k_srbind_mopen,  buttons[ SDL_CONTROLLER_BUTTON_GUIDE ] );
 335
 336       float *axis = controller->axises;
 337
 338       float *steer = srinput.joystick_states[ k_srjoystick_steer ][0],
 339             *look  = srinput.joystick_states[ k_srjoystick_look ][0],
 340             *grab  = srinput.joystick_states[ k_srjoystick_grab ][0],
 341             *axisgrab = &srinput.axis_states[ k_sraxis_grab ][0],
 342             *axisbrowseh = &srinput.axis_states[ k_sraxis_mbrowse_h ][0],
 343             *axisbrowsev = &srinput.axis_states[ k_sraxis_mbrowse_v ][0];
 344
 345       steer[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
 346       steer[1] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
 347       look[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
 348       look[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
 349       grab[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
 350       grab[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
 351       axisgrab[0] += vg_maxf( 0.0f, axis[ SDL_CONTROLLER_AXIS_TRIGGERRIGHT ] );
 352       axisbrowseh[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
 353       axisbrowsev[0] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
 354
 355       float lh = axis[ SDL_CONTROLLER_AXIS_LEFTX ],
 356             lv = axis[ SDL_CONTROLLER_AXIS_LEFTY ],
 357             sensitivity = 0.35f;
 358
 359       if( lh >  sensitivity ) setbtn( k_srbind_mright, 1 );
 360       if( lh < -sensitivity ) setbtn( k_srbind_mleft, 1 );
 361       if( lv >  sensitivity ) setbtn( k_srbind_mup, 1 );
 362       if( lv < -sensitivity ) setbtn( k_srbind_mdown, 1 );
 363    }
 364
 365    srinput.axis_states[ k_sraxis_grab ][0] =
 366       vg_minf( 1.0f, srinput.axis_states[ k_sraxis_grab ][0] );
 367 }
 368
 369 #endif /* INPUT_H */