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 ) return 1;
 183    if( vg_ui.wants_mouse ) return 1;
 184
 185    if( vg.engine_stage == k_engine_stage_update_fixed )
 186       if( vg.fixed_iterations > 0 )
 187          return 1;
 188
 189    return 0;
 190 }
 191
 192 /* Rising edge of button */
 193 static int button_down( enum sr_bind button )
 194 {
 195    if( buttons_filter_fixed() ) return 0;
 196
 197    if(  srinput.button_states[ button ][0] &&
 198        !srinput.button_states[ button ][1] )
 199       return 1;
 200    else
 201       return 0;
 202 }
 203
 204 /* Falling edge of button */
 205 static int button_up( enum sr_bind button )
 206 {
 207    if( buttons_filter_fixed() ) return 0;
 208
 209    if( !srinput.button_states[ button ][0] &&
 210         srinput.button_states[ button ][1] )
 211       return 1;
 212    else
 213       return 0;
 214 }
 215
 216 /* State of button */
 217 static int button_press( enum sr_bind button )
 218 {
 219    if( vg_ui.wants_mouse ) return 0;
 220    return srinput.button_states[ button ][0];
 221 }
 222
 223 static void joystick_state( enum sr_joystick joystick, v2f state )
 224 {
 225    if( vg_ui.wants_mouse )
 226       v2_zero( state );
 227    else
 228       v2_copy( srinput.joystick_states[ joystick ][0], state );
 229 }
 230
 231 static float axis_state( enum sr_axis axis )
 232 {
 233    if( vg_ui.wants_mouse ) return 0.0f;
 234    else return srinput.axis_states[axis][0];
 235 }
 236
 237 static void setbtn( enum sr_bind button, u8 value )
 238 {
 239    srinput.button_states[button][0] |= value;
 240 }
 241
 242 static void skaterift_preupdate_inputs(void)
 243 {
 244    if( srinput.ignore_input_frames )
 245       srinput.ignore_input_frames --;
 246
 247    for( u32 i=0; i<k_srbind_max; i++ ){
 248       srinput.button_states[i][1] = srinput.button_states[i][0];
 249       srinput.button_states[i][0] = 0;
 250    }
 251
 252    for( u32 i=0; i<k_srjoystick_max; i++ ){
 253       v2_copy( srinput.joystick_states[i][0], srinput.joystick_states[i][1] );
 254       v2_zero( srinput.joystick_states[i][0] );
 255    }
 256
 257    for( u32 i=0; i<k_sraxis_max; i++ ){
 258       srinput.axis_states[i][1] = srinput.axis_states[i][0];
 259       srinput.axis_states[i][0] = 0.0f;
 260    }
 261
 262    u32 mouse = SDL_GetMouseState(NULL,NULL),
 263        mouse1= (mouse & SDL_BUTTON(SDL_BUTTON_LEFT))? 1: 0,
 264        mouse2= (mouse & SDL_BUTTON(SDL_BUTTON_RIGHT))? 1: 0;
 265
 266    /* button inputs
 267     * ------------------------------------- */
 268    setbtn( k_srbind_jump,    vg_getkey(SDLK_SPACE) );
 269    setbtn( k_srbind_push,    vg_getkey(SDLK_w) );
 270    setbtn( k_srbind_trick0,  mouse1 );
 271    setbtn( k_srbind_trick1,  mouse2 );
 272    setbtn( k_srbind_trick2,  mouse1 & mouse2 );
 273    setbtn( k_srbind_use,     vg_getkey(SDLK_e) );
 274    setbtn( k_srbind_reset,   vg_getkey(SDLK_r) );
 275    setbtn( k_srbind_camera,  vg_getkey(SDLK_c) );
 276    setbtn( k_srbind_mleft,   vg_getkey(SDLK_LEFT) );
 277    setbtn( k_srbind_mright,  vg_getkey(SDLK_RIGHT) );
 278    setbtn( k_srbind_mup,     vg_getkey(SDLK_UP) );
 279    setbtn( k_srbind_mdown,   vg_getkey(SDLK_DOWN) );
 280    setbtn( k_srbind_mback,   vg_getkey(SDLK_ESCAPE) );
 281    setbtn( k_srbind_mopen,   vg_getkey(SDLK_ESCAPE) );
 282    setbtn( k_srbind_maccept, vg_getkey(SDLK_e) );
 283    setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN));
 284    setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN2));
 285
 286    /* axis
 287     * --------------------------------------------*/
 288    srinput.axis_states[ k_sraxis_grab ][0] = vg_getkey( SDLK_LSHIFT );
 289
 290    if( vg_getkey( SDLK_d ) )
 291       srinput.joystick_states[k_srjoystick_steer][0][0] += 1.0f;
 292    if( vg_getkey( SDLK_a ) )
 293       srinput.joystick_states[k_srjoystick_steer][0][0] -= 1.0f;
 294    if( vg_getkey( SDLK_w ) )
 295       srinput.joystick_states[k_srjoystick_steer][0][1] -= 1.0f;
 296    if( vg_getkey( SDLK_s ) )
 297       srinput.joystick_states[k_srjoystick_steer][0][1] += 1.0f;
 298
 299    if( vg_getkey( SDLK_DOWN ) )
 300       srinput.axis_states[ k_sraxis_mbrowse_v ][0] -= 1.0f;
 301    if( vg_getkey( SDLK_UP ) )
 302       srinput.axis_states[ k_sraxis_mbrowse_v ][0] += 1.0f;
 303    if( vg_getkey( SDLK_LEFT ) )
 304       srinput.axis_states[ k_sraxis_mbrowse_h ][0] -= 1.0f;
 305    if( vg_getkey( SDLK_RIGHT ) )
 306       srinput.axis_states[ k_sraxis_mbrowse_h ][0] += 1.0f;
 307
 308    if( vg_input.active_controller_index >= 0 ){
 309       struct vg_controller *controller =
 310          &vg_input.controllers[vg_input.active_controller_index];
 311
 312       u32 *buttons = controller->buttons;
 313       setbtn( k_srbind_jump,   buttons[ SDL_CONTROLLER_BUTTON_A ] );
 314       setbtn( k_srbind_push,   buttons[ SDL_CONTROLLER_BUTTON_B ] );
 315       setbtn( k_srbind_trick0, buttons[ SDL_CONTROLLER_BUTTON_A ] );
 316       setbtn( k_srbind_trick1, buttons[ SDL_CONTROLLER_BUTTON_B ] );
 317       setbtn( k_srbind_trick2, buttons[ SDL_CONTROLLER_BUTTON_X ] );
 318       setbtn( k_srbind_use,    buttons[ SDL_CONTROLLER_BUTTON_Y ] );
 319       setbtn( k_srbind_reset,  buttons[ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] );
 320       setbtn( k_srbind_camera, buttons[ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ] );
 321       setbtn( k_srbind_mleft,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] );
 322       setbtn( k_srbind_mright, buttons[ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ] );
 323       setbtn( k_srbind_mup,    buttons[ SDL_CONTROLLER_BUTTON_DPAD_UP ] );
 324       setbtn( k_srbind_mdown,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_DOWN ] );
 325       setbtn( k_srbind_mback,  buttons[ SDL_CONTROLLER_BUTTON_B ] );
 326       setbtn( k_srbind_maccept,buttons[ SDL_CONTROLLER_BUTTON_A ] );
 327       setbtn( k_srbind_mopen,  buttons[ SDL_CONTROLLER_BUTTON_GUIDE ] );
 328
 329       float *axis = controller->axises;
 330
 331       float *steer = srinput.joystick_states[ k_srjoystick_steer ][0],
 332             *look  = srinput.joystick_states[ k_srjoystick_look ][0],
 333             *grab  = srinput.joystick_states[ k_srjoystick_grab ][0],
 334             *axisgrab = &srinput.axis_states[ k_sraxis_grab ][0],
 335             *axisbrowseh = &srinput.axis_states[ k_sraxis_mbrowse_h ][0],
 336             *axisbrowsev = &srinput.axis_states[ k_sraxis_mbrowse_v ][0];
 337
 338       steer[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
 339       steer[1] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
 340       look[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
 341       look[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
 342       grab[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
 343       grab[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
 344       axisgrab[0] += vg_maxf( 0.0f, axis[ SDL_CONTROLLER_AXIS_TRIGGERRIGHT ] );
 345       axisbrowseh[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
 346       axisbrowsev[0] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
 347
 348       float lh = axis[ SDL_CONTROLLER_AXIS_LEFTX ],
 349             lv = axis[ SDL_CONTROLLER_AXIS_LEFTY ],
 350             sensitivity = 0.35f;
 351
 352       if( lh >  sensitivity ) setbtn( k_srbind_mright, 1 );
 353       if( lh < -sensitivity ) setbtn( k_srbind_mleft, 1 );
 354       if( lv >  sensitivity ) setbtn( k_srbind_mup, 1 );
 355       if( lv < -sensitivity ) setbtn( k_srbind_mdown, 1 );
 356    }
 357
 358    srinput.axis_states[ k_sraxis_grab ][0] =
 359       vg_minf( 1.0f, srinput.axis_states[ k_sraxis_grab ][0] );
 360 }
 361
 362 #endif /* INPUT_H */