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_sit,
  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_replay_play,
  30    k_srbind_replay_freecam,
  31    k_srbind_replay_resume,
  32    k_srbind_world_left,
  33    k_srbind_world_right,
  34    k_srbind_home,
  35    k_srbind_lobby,
  36    k_srbind_chat,
  37    k_srbind_max,
  38 };
  39
  40 enum sr_joystick{
  41    k_srjoystick_steer = 0,
  42    k_srjoystick_grab,
  43    k_srjoystick_look,
  44    k_srjoystick_max
  45 };
  46
  47 enum sr_axis{
  48    k_sraxis_grab = 0,
  49    k_sraxis_mbrowse_h,
  50    k_sraxis_mbrowse_v,
  51    k_sraxis_replay_h,
  52    k_sraxis_max
  53 };
  54
  55
  56 #define INPUT_BASIC( KB, JS ) \
  57    (vg_input_op[]){vg_keyboard, KB, vg_joy_button, JS, vg_end}
  58
  59 static vg_input_op *input_button_list[] = {
  60 [k_srbind_jump]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
  61 [k_srbind_push]  = INPUT_BASIC( SDLK_w, SDL_CONTROLLER_BUTTON_B ),
  62 [k_srbind_trick0] = (vg_input_op[]){
  63    vg_mouse, SDL_BUTTON_LEFT,
  64    vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
  65 },
  66 [k_srbind_trick1] = (vg_input_op[]){
  67    vg_mouse, SDL_BUTTON_RIGHT,
  68    vg_joy_button, SDL_CONTROLLER_BUTTON_B, vg_end
  69 },
  70 [k_srbind_trick2] = (vg_input_op[]){
  71    vg_mouse, SDL_BUTTON_LEFT, vg_mode_mul, vg_mouse, SDL_BUTTON_RIGHT,
  72    vg_mode_absmax, vg_joy_button, SDL_CONTROLLER_BUTTON_X, vg_end
  73 },
  74 [k_srbind_use]   = INPUT_BASIC( SDLK_e, SDL_CONTROLLER_BUTTON_Y ),
  75 [k_srbind_reset] = INPUT_BASIC( SDLK_r, SDL_CONTROLLER_BUTTON_LEFTSHOULDER ),
  76 [k_srbind_camera]= INPUT_BASIC( SDLK_c, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ),
  77 [k_srbind_mleft] = INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  78 [k_srbind_mright]= INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
  79 [k_srbind_world_left] =
  80                    INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  81 [k_srbind_world_right] =
  82                    INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
  83 [k_srbind_home]  = INPUT_BASIC( SDLK_h, SDL_CONTROLLER_BUTTON_Y ),
  84 [k_srbind_mup]   = INPUT_BASIC( SDLK_UP, SDL_CONTROLLER_BUTTON_DPAD_UP ),
  85 [k_srbind_mdown] = INPUT_BASIC( SDLK_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN ),
  86 [k_srbind_mback] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_B ),
  87 [k_srbind_mopen] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_START ),
  88 [k_srbind_maccept] = (vg_input_op[]){
  89    vg_keyboard, SDLK_e, vg_gui_visible, 0,
  90       vg_keyboard, SDLK_RETURN, vg_keyboard, SDLK_RETURN2,
  91    vg_gui_visible, 1,
  92    vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
  93 },
  94 [k_srbind_replay_play]    = INPUT_BASIC( SDLK_g, SDL_CONTROLLER_BUTTON_X ),
  95 [k_srbind_replay_resume]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
  96 [k_srbind_replay_freecam] = INPUT_BASIC( SDLK_f, SDL_CONTROLLER_BUTTON_Y ),
  97 [k_srbind_sit]   = INPUT_BASIC( SDLK_z, SDL_CONTROLLER_BUTTON_B ),
  98 [k_srbind_lobby] = INPUT_BASIC( SDLK_TAB, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
  99 [k_srbind_chat ] = (vg_input_op[]){ vg_keyboard, SDLK_y, vg_end },
 100 [k_srbind_max]=NULL
 101 };
 102
 103 static vg_input_op *input_axis_list[] = {
 104 [k_sraxis_grab] = (vg_input_op[]){
 105    vg_keyboard, SDLK_LSHIFT,
 106    vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, vg_end
 107 },
 108 [k_sraxis_mbrowse_h] = (vg_input_op[]){
 109    vg_mode_sub, vg_keyboard, SDLK_LEFT,
 110    vg_mode_add, vg_keyboard, SDLK_RIGHT,
 111    vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTX,
 112    vg_end
 113 },
 114 [k_sraxis_mbrowse_v] = (vg_input_op[]){
 115    vg_mode_add, vg_keyboard, SDLK_UP,
 116    vg_mode_sub, vg_keyboard, SDLK_DOWN,
 117    vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTY,
 118    vg_end
 119 },
 120 [k_sraxis_replay_h] = (vg_input_op[]){
 121    vg_mode_add, vg_keyboard, SDLK_e,
 122    vg_mode_sub, vg_keyboard, SDLK_q,
 123    vg_mode_add, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
 124    vg_mode_sub, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERLEFT,
 125    vg_end
 126 },
 127 [k_sraxis_max]=NULL
 128 };
 129
 130 static vg_input_op *input_joy_list[] = {
 131 [k_srjoystick_steer] = (vg_input_op[]){
 132    vg_index, 0, vg_mode_add, vg_keyboard, SDLK_d,
 133                 vg_mode_sub, vg_keyboard, SDLK_a,
 134    vg_index, 1, vg_mode_add, vg_keyboard, SDLK_s,
 135                 vg_mode_sub, vg_keyboard, SDLK_w,
 136                 vg_mode_absmax, vg_joy_ls,
 137    vg_end
 138 },
 139 [k_srjoystick_grab] = (vg_input_op[]){
 140    vg_joy_rs, vg_end
 141 },
 142 [k_srjoystick_look] = (vg_input_op[]){
 143    vg_joy_rs, vg_end
 144 },
 145 [k_srjoystick_max]=NULL
 146 };
 147
 148 struct {
 149    float axis_states[ k_sraxis_max ][2];
 150    v2f joystick_states[ k_srjoystick_max ][2];
 151    u8 button_states[ k_srbind_max ][2];
 152
 153    enum input_state {
 154       k_input_state_enabled,
 155       k_input_state_resume,
 156       k_input_state_resuming,
 157       k_input_state_pause
 158    }
 159    state;
 160 }
 161 static srinput;
 162
 163 static int input_filter_generic(void){
 164    if( srinput.state != k_input_state_enabled ||
 165        vg_ui.wants_mouse || vg_console.enabled )
 166       return 1;
 167    else
 168       return 0;
 169 }
 170
 171 static int buttons_filter_fixed(void){
 172    if( input_filter_generic() )
 173       return 1;
 174
 175    if( vg.engine_stage == k_engine_stage_update_fixed )
 176       if( vg.fixed_iterations > 0 )
 177          return 1;
 178
 179    return 0;
 180 }
 181
 182 /* Rising edge of button */
 183 static int button_down( enum sr_bind button ){
 184    if( buttons_filter_fixed() ) return 0;
 185
 186    if(  srinput.button_states[ button ][0] &&
 187        !srinput.button_states[ button ][1] )
 188       return 1;
 189    else
 190       return 0;
 191 }
 192
 193 /* Falling edge of button */
 194 static int button_up( enum sr_bind button ){
 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 /* State of button */
 205 static int button_press( enum sr_bind button ){
 206    if( input_filter_generic() )
 207       return 0;
 208    return
 209       srinput.button_states[ button ][0];
 210 }
 211
 212 static void joystick_state( enum sr_joystick joystick, v2f state ){
 213    if( input_filter_generic() )
 214       v2_zero( state );
 215    else
 216       v2_copy( srinput.joystick_states[ joystick ][0], state );
 217 }
 218
 219 static float axis_state( enum sr_axis axis ){
 220    if( input_filter_generic() )
 221       return 0.0f;
 222    else
 223       return srinput.axis_states[axis][0];
 224 }
 225
 226 static void skaterift_preupdate_inputs(void){
 227    if( srinput.state == k_input_state_resuming )
 228       srinput.state = k_input_state_enabled;
 229
 230    if( srinput.state == k_input_state_resume )
 231       srinput.state = k_input_state_resuming;
 232
 233    for( u32 i=0; i<k_srbind_max; i++ ){
 234       srinput.button_states[i][1] = srinput.button_states[i][0];
 235       srinput.button_states[i][0] = 0;
 236    }
 237
 238    for( u32 i=0; i<k_srjoystick_max; i++ ){
 239       v2_copy( srinput.joystick_states[i][0], srinput.joystick_states[i][1] );
 240       v2_zero( srinput.joystick_states[i][0] );
 241    }
 242
 243    for( u32 i=0; i<k_sraxis_max; i++ ){
 244       srinput.axis_states[i][1] = srinput.axis_states[i][0];
 245       srinput.axis_states[i][0] = 0.0f;
 246    }
 247
 248    for( int i=0; i<k_srbind_max; i++ ){
 249       vg_input_op *prog = input_button_list[i];
 250       if( prog ){
 251          vg_exec_input_program( k_vg_input_type_button_u8, prog,
 252                                 &srinput.button_states[i][0] );
 253       }
 254    }
 255
 256    for( int i=0; i<k_sraxis_max; i++ ){
 257       vg_input_op *prog = input_axis_list[i];
 258       if( prog ){
 259          vg_exec_input_program( k_vg_input_type_axis_f32, prog,
 260                                 &srinput.axis_states[i][0] );
 261       }
 262    }
 263
 264    for( int i=0; i<k_srjoystick_max; i++ ){
 265       vg_input_op *prog = input_joy_list[i];
 266       if( prog ){
 267          vg_exec_input_program( k_vg_input_type_joy_v2f, prog,
 268                                 srinput.joystick_states[i][0] );
 269       }
 270    }
 271
 272    f32 x = srinput.axis_states[k_sraxis_mbrowse_h][0],
 273        y = srinput.axis_states[k_sraxis_mbrowse_v][0],
 274        sensitivity = 0.35f;
 275
 276    if( fabsf(x) > sensitivity ){
 277       if( x > 0.0f ) srinput.button_states[k_srbind_mright][0] = 1;
 278       else           srinput.button_states[k_srbind_mleft][0] = 1;
 279    }
 280
 281    if( fabsf(y) > sensitivity ){
 282       if( y > 0.0f ) srinput.button_states[k_srbind_mup][0] = 1;
 283       else           srinput.button_states[k_srbind_mdown][0] = 1;
 284    }
 285 }
 286
 287 #endif /* INPUT_H */