scuffed input compression pt1

diff --git a/input.h b/input.h
index ee7cbee9e5f9d5828e970998878d78c7a20ffa34..cdb93a3ce7162f1fd7900157a53e6a51d317952f 100644 (file)
--- a/input.h
+++ b/input.h
@@ -54,11 +54,113 @@ enum sr_axis{
    k_sraxis_max
 };
 
+
+#define INPUT_BASIC( KB, JS ) \
+   (vg_input_op[]){vg_keyboard, KB, vg_joy_button, JS, vg_end}
+
+static vg_input_op *input_button_list[] = {
+[k_srbind_jump]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
+[k_srbind_push]  = INPUT_BASIC( SDLK_w, SDL_CONTROLLER_BUTTON_B ),
+[k_srbind_trick0] = (vg_input_op[]){
+   vg_mouse, SDL_BUTTON_LEFT,
+   vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
+},
+[k_srbind_trick1] = (vg_input_op[]){
+   vg_mouse, SDL_BUTTON_RIGHT,
+   vg_joy_button, SDL_CONTROLLER_BUTTON_B, vg_end
+},
+[k_srbind_trick2] = (vg_input_op[]){ 
+   vg_mode_mul, vg_mouse, SDL_BUTTON_LEFT, vg_mouse, SDL_BUTTON_RIGHT, 
+   vg_mode_absmax, vg_joy_button, SDL_CONTROLLER_BUTTON_X, vg_end 
+},
+[k_srbind_use]   = INPUT_BASIC( SDLK_e, SDL_CONTROLLER_BUTTON_Y ),
+[k_srbind_reset] = INPUT_BASIC( SDLK_r, SDL_CONTROLLER_BUTTON_LEFTSHOULDER ),
+[k_srbind_camera]= INPUT_BASIC( SDLK_c, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ),
+[k_srbind_mleft] = INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
+[k_srbind_mright]= INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
+[k_srbind_world_left] = 
+                   INPUT_BASIC( SDLK_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
+[k_srbind_world_right] =
+                   INPUT_BASIC( SDLK_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
+[k_srbind_home]  = INPUT_BASIC( SDLK_h, SDL_CONTROLLER_BUTTON_Y ),
+[k_srbind_mup]   = INPUT_BASIC( SDLK_UP, SDL_CONTROLLER_BUTTON_DPAD_UP ),
+[k_srbind_mdown] = INPUT_BASIC( SDLK_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN ),
+[k_srbind_mback] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_B ),
+[k_srbind_mopen] = INPUT_BASIC( SDLK_ESCAPE, SDL_CONTROLLER_BUTTON_START ),
+[k_srbind_maccept] = (vg_input_op[]){
+   vg_keyboard, SDLK_e, vg_keyboard, SDLK_RETURN, vg_keyboard, SDLK_RETURN2,
+   vg_joy_button, SDL_CONTROLLER_BUTTON_A, vg_end
+},
+[k_srbind_replay_play]    = INPUT_BASIC( SDLK_g, SDL_CONTROLLER_BUTTON_X ),
+[k_srbind_replay_resume]  = INPUT_BASIC( SDLK_SPACE, SDL_CONTROLLER_BUTTON_A ),
+[k_srbind_replay_freecam] = INPUT_BASIC( SDLK_f, SDL_CONTROLLER_BUTTON_Y ),
+[k_srbind_sit]   = INPUT_BASIC( SDLK_z, SDL_CONTROLLER_BUTTON_B ),
+[k_srbind_lobby] = INPUT_BASIC( SDLK_TAB, SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
+[k_srbind_chat ] = (vg_input_op[]){ vg_keyboard, SDLK_y, vg_end },
+[k_srbind_max]=NULL
+};
+
+static vg_input_op *input_axis_list[] = {
+[k_sraxis_grab] = (vg_input_op[]){
+   vg_keyboard, SDLK_LSHIFT, 
+   vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, vg_end
+},
+[k_sraxis_mbrowse_h] = (vg_input_op[]){
+   vg_mode_add, vg_keyboard, SDLK_RIGHT,
+   vg_mode_sub, vg_keyboard, SDLK_LEFT,
+   vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTX,
+   vg_end
+},
+[k_sraxis_mbrowse_v] = (vg_input_op[]){
+   vg_mode_add, vg_keyboard, SDLK_UP,
+   vg_mode_sub, vg_keyboard, SDLK_DOWN,
+   vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTY,
+   vg_end
+},
+[k_sraxis_replay_h] = (vg_input_op[]){
+   vg_mode_add, vg_keyboard, SDLK_e,
+   vg_mode_sub, vg_keyboard, SDLK_q,
+   vg_mode_add, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
+   vg_mode_sub, vg_joy_axis, SDL_CONTROLLER_AXIS_TRIGGERLEFT,
+   vg_end
+},
+[k_sraxis_max]=NULL
+};
+
+static vg_input_op *input_joy_list[] = {
+[k_srjoystick_steer] = (vg_input_op[]){
+   vg_index, 0, vg_mode_add, vg_keyboard, SDLK_d,
+                vg_mode_sub, vg_keyboard, SDLK_a,
+                vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTX, 
+   vg_index, 1, vg_mode_add, vg_keyboard, SDLK_s,
+                vg_mode_sub, vg_keyboard, SDLK_w,
+                vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_LEFTY,
+   vg_end
+},
+[k_srjoystick_grab] = (vg_input_op[]){
+   vg_index, 0, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTX,
+   vg_index, 1, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTY,
+   vg_end
+},
+[k_srjoystick_look] = (vg_input_op[]){
+   vg_index, 0, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTX,
+   vg_index, 1, vg_mode_absmax, vg_joy_axis, SDL_CONTROLLER_AXIS_RIGHTY,
+   vg_end
+},
+[k_srjoystick_max]=NULL
+};
+
 struct {
    float axis_states[ k_sraxis_max ][2];
    v2f joystick_states[ k_srjoystick_max ][2];
    u8 button_states[ k_srbind_max ][2];
-   u32 enabled;
+
+   enum input_state {
+      k_input_state_enabled,
+      k_input_state_resume,
+      k_input_state_pause
+   }
+   state;
 }
 static srinput;
 
@@ -214,7 +316,8 @@ static const char *joystick_display_string( enum sr_joystick joystick,
 }
 
 static int input_filter_generic(void){
-   if( !srinput.enabled || vg_ui.wants_mouse || vg_console.enabled )
+   if( srinput.state != k_input_state_enabled || 
+       vg_ui.wants_mouse || vg_console.enabled )
       return 1;
    else 
       return 0;
@@ -280,8 +383,10 @@ static void setbtn( enum sr_bind button, u8 value )
    srinput.button_states[button][0] |= value;
 }
 
-static void skaterift_preupdate_inputs(void)
-{
+static void skaterift_preupdate_inputs(void){
+   if( srinput.state == k_input_state_resume )
+      srinput.state = k_input_state_enabled;
+
    for( u32 i=0; i<k_srbind_max; i++ ){
       srinput.button_states[i][1] = srinput.button_states[i][0];
       srinput.button_states[i][0] = 0;
@@ -301,131 +406,29 @@ static void skaterift_preupdate_inputs(void)
        mouse1= (mouse & SDL_BUTTON(SDL_BUTTON_LEFT))? 1: 0,
        mouse2= (mouse & SDL_BUTTON(SDL_BUTTON_RIGHT))? 1: 0;
 
-   /* button inputs
-    * ------------------------------------- */
-   setbtn( k_srbind_jump,    vg_getkey(SDLK_SPACE) );
-   setbtn( k_srbind_push,    vg_getkey(SDLK_w) );
-   setbtn( k_srbind_trick0,  mouse1 );
-   setbtn( k_srbind_trick1,  mouse2 );
-   setbtn( k_srbind_trick2,  mouse1 & mouse2 );
-   setbtn( k_srbind_use,     vg_getkey(SDLK_e) );
-   setbtn( k_srbind_reset,   vg_getkey(SDLK_r) );
-   setbtn( k_srbind_camera,  vg_getkey(SDLK_c) );
-   setbtn( k_srbind_mleft,   vg_getkey(SDLK_LEFT) );
-   setbtn( k_srbind_mright,  vg_getkey(SDLK_RIGHT) );
-   setbtn( k_srbind_world_left,   vg_getkey(SDLK_LEFT) );
-   setbtn( k_srbind_world_right,  vg_getkey(SDLK_RIGHT) );
-   setbtn( k_srbind_home,  vg_getkey(SDLK_h) );
-   setbtn( k_srbind_mup,     vg_getkey(SDLK_UP) );
-   setbtn( k_srbind_mdown,   vg_getkey(SDLK_DOWN) );
-   setbtn( k_srbind_mback,   vg_getkey(SDLK_ESCAPE) );
-   setbtn( k_srbind_mopen,   vg_getkey(SDLK_ESCAPE) );
-   setbtn( k_srbind_maccept, vg_getkey(SDLK_e) );
-   setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN));
-   setbtn( k_srbind_maccept, vg_getkey(SDLK_RETURN2));
-   setbtn( k_srbind_replay_play, vg_getkey(SDLK_g) );
-   setbtn( k_srbind_replay_freecam, vg_getkey(SDLK_f) );
-   setbtn( k_srbind_replay_resume, vg_getkey(SDLK_SPACE) );
-   setbtn( k_srbind_sit, vg_getkey(SDLK_z) );
-   setbtn( k_srbind_lobby, vg_getkey(SDLK_TAB) );
-   setbtn( k_srbind_chat, vg_getkey(SDLK_y) );
-
-   /* axis
-    * --------------------------------------------*/
-   srinput.axis_states[ k_sraxis_grab ][0] = vg_getkey( SDLK_LSHIFT );
-
-   if( vg_getkey( SDLK_e ) )
-      srinput.axis_states[ k_sraxis_replay_h ][0] += 1.0f;
-   if( vg_getkey( SDLK_q ) )
-      srinput.axis_states[ k_sraxis_replay_h ][0] -= 1.0f;
-
-   if( vg_getkey( SDLK_d ) )
-      srinput.joystick_states[k_srjoystick_steer][0][0] += 1.0f;
-   if( vg_getkey( SDLK_a ) )
-      srinput.joystick_states[k_srjoystick_steer][0][0] -= 1.0f;
-   if( vg_getkey( SDLK_w ) ) 
-      srinput.joystick_states[k_srjoystick_steer][0][1] -= 1.0f;
-   if( vg_getkey( SDLK_s ) ) 
-      srinput.joystick_states[k_srjoystick_steer][0][1] += 1.0f;
-
-   if( vg_getkey( SDLK_DOWN ) )
-      srinput.axis_states[ k_sraxis_mbrowse_v ][0] -= 1.0f;
-   if( vg_getkey( SDLK_UP ) )
-      srinput.axis_states[ k_sraxis_mbrowse_v ][0] += 1.0f;
-
-   if( vg_getkey( SDLK_LEFT ) ){
-      srinput.axis_states[ k_sraxis_mbrowse_h ][0] -= 1.0f;
-      srinput.axis_states[ k_sraxis_mworld_h ][0] -= 1.0f;
-   }
-   if( vg_getkey( SDLK_RIGHT ) ){
-      srinput.axis_states[ k_sraxis_mbrowse_h ][0] += 1.0f;
-      srinput.axis_states[ k_sraxis_mworld_h ][0] += 1.0f;
+   for( int i=0; i<k_srbind_max; i++ ){
+      vg_input_op *prog = input_button_list[i];
+      if( prog ){
+         vg_exec_input_program( k_vg_input_type_button_u8, prog,
+                                &srinput.button_states[i][0] );
+      }
    }
 
-   if( vg_input.active_controller_index >= 0 ){
-      struct vg_controller *controller = 
-         &vg_input.controllers[vg_input.active_controller_index];
-
-      u32 *buttons = controller->buttons;
-      setbtn( k_srbind_jump,   buttons[ SDL_CONTROLLER_BUTTON_A ] );
-      setbtn( k_srbind_push,   buttons[ SDL_CONTROLLER_BUTTON_B ] );
-      setbtn( k_srbind_trick0, buttons[ SDL_CONTROLLER_BUTTON_A ] );
-      setbtn( k_srbind_trick1, buttons[ SDL_CONTROLLER_BUTTON_B ] );
-      setbtn( k_srbind_trick2, buttons[ SDL_CONTROLLER_BUTTON_X ] );
-      setbtn( k_srbind_use,    buttons[ SDL_CONTROLLER_BUTTON_Y ] );
-      setbtn( k_srbind_reset,  buttons[ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] );
-      setbtn( k_srbind_camera, buttons[ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ] );
-      setbtn( k_srbind_mleft,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] );
-      setbtn( k_srbind_mright, buttons[ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ] );
-      setbtn( k_srbind_world_left, buttons[ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] );
-      setbtn( k_srbind_world_right,buttons[ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ]);
-      setbtn( k_srbind_home, buttons[ SDL_CONTROLLER_BUTTON_Y ] );
-      setbtn( k_srbind_mup,    buttons[ SDL_CONTROLLER_BUTTON_DPAD_UP ] );
-      setbtn( k_srbind_mdown,  buttons[ SDL_CONTROLLER_BUTTON_DPAD_DOWN ] );
-      setbtn( k_srbind_mback,  buttons[ SDL_CONTROLLER_BUTTON_B ] );
-      setbtn( k_srbind_maccept,buttons[ SDL_CONTROLLER_BUTTON_A ] );
-      setbtn( k_srbind_mopen,  buttons[ SDL_CONTROLLER_BUTTON_START ] );
-      setbtn( k_srbind_mback,  buttons[ SDL_CONTROLLER_BUTTON_START ] );
-      setbtn( k_srbind_replay_resume, buttons[ SDL_CONTROLLER_BUTTON_A ] );
-      setbtn( k_srbind_replay_play, buttons[ SDL_CONTROLLER_BUTTON_X ] );
-      setbtn( k_srbind_replay_freecam, buttons[ SDL_CONTROLLER_BUTTON_Y ] );
-      setbtn( k_srbind_sit, buttons[ SDL_CONTROLLER_BUTTON_B ] );
-      setbtn( k_srbind_lobby, buttons[ SDL_CONTROLLER_BUTTON_DPAD_LEFT ] );
-      // k_srbind_chat 
-
-      float *axis = controller->axises;
-      float *steer = srinput.joystick_states[ k_srjoystick_steer ][0],
-            *look  = srinput.joystick_states[ k_srjoystick_look ][0],
-            *grab  = srinput.joystick_states[ k_srjoystick_grab ][0],
-            *axisgrab = &srinput.axis_states[ k_sraxis_grab ][0],
-            *axisbrowseh = &srinput.axis_states[ k_sraxis_mbrowse_h ][0],
-            *axisbrowsev = &srinput.axis_states[ k_sraxis_mbrowse_v ][0],
-            *axisreplayh = &srinput.axis_states[ k_sraxis_replay_h ][0];
-      
-      steer[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
-      steer[1] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
-      look[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
-      look[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
-      grab[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
-      grab[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
-      axisgrab[0] += vg_maxf( 0.0f, axis[ SDL_CONTROLLER_AXIS_TRIGGERRIGHT ] );
-      axisbrowseh[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ];
-      axisbrowsev[0] += axis[ SDL_CONTROLLER_AXIS_LEFTY ];
-      axisreplayh[0] += vg_maxf(0.0f,axis[SDL_CONTROLLER_AXIS_TRIGGERRIGHT]);
-      axisreplayh[0] -= vg_maxf(0.0f,axis[SDL_CONTROLLER_AXIS_TRIGGERLEFT]);
-
-      float lh = axis[ SDL_CONTROLLER_AXIS_LEFTX ],
-            lv = axis[ SDL_CONTROLLER_AXIS_LEFTY ],
-            sensitivity = 0.35f;
-
-      if( lh >  sensitivity ) setbtn( k_srbind_mright, 1 );
-      if( lh < -sensitivity ) setbtn( k_srbind_mleft, 1 );
-      if( lv >  sensitivity ) setbtn( k_srbind_mdown, 1 );
-      if( lv < -sensitivity ) setbtn( k_srbind_mup, 1 );
+   for( int i=0; i<k_sraxis_max; i++ ){
+      vg_input_op *prog = input_axis_list[i];
+      if( prog ){
+         vg_exec_input_program( k_vg_input_type_axis_f32, prog,
+                                &srinput.axis_states[i][0] );
+      }
    }
 
-   srinput.axis_states[ k_sraxis_grab ][0] = 
-      vg_minf( 1.0f, srinput.axis_states[ k_sraxis_grab ][0] );
+   for( int i=0; i<k_srjoystick_max; i++ ){
+      vg_input_op *prog = input_joy_list[i];
+      if( prog ){
+         vg_exec_input_program( k_vg_input_type_joy_v2f, prog,
+                                srinput.joystick_states[i][0] );
+      }
+   }
 }
 
 #endif /* INPUT_H */

diff --git a/menu.h b/menu.h
index 86f573620f5fa10ecabe789d0a8d09b5590bc3c3..5143c511cf122ff6d862093ce3748283365a814c 100644 (file)
--- a/menu.h
+++ b/menu.h
@@ -129,7 +129,7 @@ static void menu_close(void){
    skaterift.activity = k_skaterift_default;
    menu.page_depth = 0;
    menu.page = 0xffffffff;
-   srinput.enabled = 0;
+   srinput.state = k_input_state_resume;
 }
 
 static void menu_init(void){

diff --git a/player_remote.c b/player_remote.c
index 50249328d2fddc0812f95e6f0c557f0e21862e7d..d9f0065ee9f172d7d2ae0f16fc65323f661c2ac9 100644 (file)
--- a/player_remote.c
+++ b/player_remote.c
@@ -921,16 +921,16 @@ static void remote_players_chat_imgui(void){
                   UI_TEXTBOX_AUTOFOCUS, &callbacks );
    }
    else {
-      /* TODO: we gotta fix this input fighting crap. */
       if( netplayers.chatting == -1 ){
          netplayers.chatting = 0;
+         srinput.state = k_input_state_resume;
       }
       else {
          if( (skaterift.activity == k_skaterift_default) && 
                button_down( k_srbind_chat ) ){
             netplayers.chatting = 1;
             netplayers.chat_buffer[0] = '\0';
-            srinput.enabled = 0;
+            srinput.state = k_input_state_pause;
          }
       }
    }

diff --git a/player_replay.c b/player_replay.c
index 04650b73b81ed05d2de6de8ea482cad313553abe..b9172c73b0c3c04664d6bdd63b31741859f67ee2 100644 (file)
--- a/player_replay.c
+++ b/player_replay.c
@@ -440,7 +440,7 @@ static void skaterift_replay_pre_update(void){
             skaterift_restore_frame( skaterift.replay.statehead );
          else
             skaterift.activity = k_skaterift_default;
-         srinput.enabled = 0;
+         srinput.state = k_input_state_resume;
       }
 
       gui_helper_action( button_display_string(k_srbind_replay_play), "play" );

diff --git a/respawn.c b/respawn.c
index 5abb042f7a54ad92cd348e5e7e2f9af421ec153c..e90f9be3ebf389fb088370ad67905beb2a39e9dd 100644 (file)
--- a/respawn.c
+++ b/respawn.c
@@ -94,7 +94,7 @@ static void respawn_chooser_pre_update(void){
    gui_helper_action( button_display_string(k_srbind_home), "home" );
 
    if( button_down( k_srbind_mback ) ){
-      srinput.enabled = 0;
+      srinput.state = k_input_state_resume;
       skaterift.activity = k_skaterift_menu;
       menu.page = 0xffffffff;
       menu_open_page( "Main Menu", k_ent_menuitem_stack_append );
@@ -103,7 +103,7 @@ static void respawn_chooser_pre_update(void){
 
    if( button_down( k_srbind_maccept ) ){
       skaterift.activity = k_skaterift_default;
-      srinput.enabled = 0;
+      srinput.state = k_input_state_resume;
 
       if( respawn_chooser.spawn ){
          world_static.active_instance = respawn_chooser.world_id;

diff --git a/skaterift.c b/skaterift.c
index edbfb23fa3829ab7d4b0a419f44a0306e703935f..113f65ac8e806d77de2bb02002c50ce489dcde21 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -306,9 +306,6 @@ static void skaterift_change_client_world_preupdate(void);
  * ---------------------------------------------------------------------------*/
 
 static void vg_pre_update(void){
-   if( !netplayers.chatting ) /* FIXME */
-      srinput.enabled = 1;
-
    skaterift_preupdate_inputs();
 
    if( k_tools_mode ) return;

diff --git a/world_entity.c b/world_entity.c
index eccf2b4f7afed09c36d349b6432e86015d3c63fc..e0c67d82645bd0100701b2186023be07bbbbbd27 100644 (file)
--- a/world_entity.c
+++ b/world_entity.c
@@ -27,7 +27,7 @@ static void world_entity_unfocus(void){
    localplayer.immobile = 0;
    skaterift.activity = k_skaterift_default;
    menu.disable_open = 0;
-   srinput.enabled = 0;
+   srinput.state = k_input_state_resume;
 }
 
 static void world_entity_focus_camera( world_instance *world, u32 uid ){