the pain is gone
[carveJwlIkooP6JGAAIwe30JlM.git] / input.h
diff --git a/input.h b/input.h
index c6710f2696809e56b2c05b375cc78eef6b6a09bb..6f19634f606e4dde10fd52754dbcaf9d3804cd66 100644 (file)
--- a/input.h
+++ b/input.h
@@ -8,6 +8,7 @@
 #include "vg/vg_input.h"
 #include "vg/vg_m.h"
 #include "conf.h"
+#include "font.h"
 
 enum sr_bind{
    k_srbind_jump = 0,
@@ -24,29 +25,174 @@ enum sr_bind{
    k_srbind_mdown,
    k_srbind_mback, 
    k_srbind_maccept,
-   k_srbind_max
+   k_srbind_mopen,
+   k_srbind_max,
 };
 
-struct {
-   v2f joy_steer,
-       joy_grab,
-       joy_look;
+enum sr_joystick{
+   k_srjoystick_steer = 0,
+   k_srjoystick_grab,
+   k_srjoystick_look,
+   k_srjoystick_max
+};
 
-   float axis_grab;
+enum sr_axis{
+   k_sraxis_grab = 0,
+   k_sraxis_mbrowse_h,
+   k_sraxis_mbrowse_v,
+   k_sraxis_max
+};
 
+struct {
+   float axis_states[ k_sraxis_max ][2];
+   v2f joystick_states[ k_srjoystick_max ][2];
    u8 button_states[ k_srbind_max ][2];
-   float repeaters[4];
 }
 static srinput;
 
-static int button_down( enum sr_bind button )
+static const char *controller_glyphs[ SDL_CONTROLLER_BUTTON_MAX ][2] =
+{                                        /* xbox/generic  playstation */
+   [ SDL_CONTROLLER_BUTTON_A ]            = { "\x1e\x85","\x1e\x82" },
+   [ SDL_CONTROLLER_BUTTON_B ]            = { "\x1e\x86","\x1e\x81" },
+   [ SDL_CONTROLLER_BUTTON_X ]            = { "\x1e\x83","\x1e\x7f" },
+   [ SDL_CONTROLLER_BUTTON_Y ]            = { "\x1e\x84","\x1e\x80" },
+   [ SDL_CONTROLLER_BUTTON_LEFTSTICK ]    = { "\x87",    "\x87" },
+   [ SDL_CONTROLLER_BUTTON_RIGHTSTICK ]   = { "\x8b",    "\x8b" },
+   [ SDL_CONTROLLER_BUTTON_LEFTSHOULDER ] = { "\x91",    "\x91" },
+   [ SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ]= { "\x92",    "\x92" },
+   [ SDL_CONTROLLER_BUTTON_DPAD_LEFT ]    = { "\x1e\x93","\x1e\x93" },
+   [ SDL_CONTROLLER_BUTTON_DPAD_UP ]      = { "\x1e\x94","\x1e\x94" },
+   [ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ]   = { "\x1e\x95","\x1e\x95" },
+   [ SDL_CONTROLLER_BUTTON_DPAD_DOWN ]    = { "\x1e\x96","\x1e\x96" },
+   [ SDL_CONTROLLER_BUTTON_GUIDE ]        = { "\x91",    "\x91" },
+};
+
+static const char *controller_glyph( u32 sdl_index )
+{
+   if( vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS3 ||
+       vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS4 ||
+       vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS5 )
+   {
+      return controller_glyphs[ sdl_index ][ 1 ];
+   }
+   else if( vg_input.display_input_type == 
+               SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO ||
+            vg_input.display_input_type == 
+               SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT ||
+            vg_input.display_input_type ==
+               SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_PAIR ||
+            vg_input.display_input_type ==
+               SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT )
+   {
+      return NULL;
+   }
+   else
+      return controller_glyphs[ sdl_index ][ 0 ];
+}
+
+#define KEYBOARD_GLYPH( X ) "\x1f" X "  "
+
+static const char *button_display_string( enum sr_bind button )
+{
+   const char *controller_table[ k_srbind_max ] = {
+    [k_srbind_jump]   = controller_glyph( SDL_CONTROLLER_BUTTON_A ),
+    [k_srbind_push]   = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
+    [k_srbind_trick0] = controller_glyph( SDL_CONTROLLER_BUTTON_A ),
+    [k_srbind_trick1] = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
+    [k_srbind_trick2] = controller_glyph( SDL_CONTROLLER_BUTTON_X ),
+    [k_srbind_use]    = controller_glyph( SDL_CONTROLLER_BUTTON_Y ),
+    [k_srbind_reset]  = controller_glyph( SDL_CONTROLLER_BUTTON_LEFTSHOULDER ),
+    [k_srbind_camera] = controller_glyph( SDL_CONTROLLER_BUTTON_RIGHTSHOULDER ),
+    [k_srbind_mleft]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_LEFT ),
+    [k_srbind_mright] = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_RIGHT ),
+    [k_srbind_mup]    = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_UP ),
+    [k_srbind_mdown]  = controller_glyph( SDL_CONTROLLER_BUTTON_DPAD_DOWN ),
+    [k_srbind_mback]  = controller_glyph( SDL_CONTROLLER_BUTTON_B ),
+    [k_srbind_maccept]= controller_glyph( SDL_CONTROLLER_BUTTON_A ),
+    [k_srbind_mopen]  = controller_glyph( SDL_CONTROLLER_BUTTON_GUIDE )
+   };
+
+   const char *keyboard_table[ k_srbind_max ] = {
+    [k_srbind_jump]   = KEYBOARD_GLYPH( "A" ),
+    [k_srbind_push]   = KEYBOARD_GLYPH( "W" ),
+    [k_srbind_trick0] = "\x99",
+    [k_srbind_trick1] = "\x9a",
+    [k_srbind_trick2] = "\x9b",
+    [k_srbind_use]    = KEYBOARD_GLYPH( "E" ),
+    [k_srbind_reset]  = KEYBOARD_GLYPH( "R" ),
+    [k_srbind_camera] = KEYBOARD_GLYPH( "C" ),
+    [k_srbind_mleft]  = KEYBOARD_GLYPH( "\x93" ),
+    [k_srbind_mright] = KEYBOARD_GLYPH( "\x95" ),
+    [k_srbind_mup]    = KEYBOARD_GLYPH( "\x94" ),
+    [k_srbind_mdown]  = KEYBOARD_GLYPH( "\x96" ),
+    [k_srbind_mback]  = "\xa3",
+    [k_srbind_maccept]= "\xa2",
+    [k_srbind_mopen]  = "\xa3" ,
+   };
+
+   if( vg_input.display_input_method == k_input_method_controller )
+      return controller_table[ button ];
+   else
+      return keyboard_table[ button ];
+}
+
+static const char *axis_display_string( enum sr_axis axis )
+{
+   const char *controller_table[ k_sraxis_max ] = {
+    [k_sraxis_grab]      = "\x90",
+    [k_sraxis_mbrowse_h] = "\x88",
+    [k_sraxis_mbrowse_v] = "\x89"
+   };
+
+   const char *keyboard_table[ k_sraxis_max ] = {
+    [k_sraxis_grab]      = "\x9e",
+    [k_sraxis_mbrowse_h] = KEYBOARD_GLYPH("\x93")KEYBOARD_GLYPH("\x95"),
+    [k_sraxis_mbrowse_v] = KEYBOARD_GLYPH("\x96")KEYBOARD_GLYPH("\x94")
+   };
+
+   if( vg_input.display_input_method == k_input_method_controller )
+      return controller_table[ axis ];
+   else
+      return keyboard_table[ axis ];
+}
+
+static const char *joystick_display_string( enum sr_joystick joystick )
+{
+   const char *controller_table[ k_srjoystick_max ] = {
+    [k_srjoystick_steer] = "\x88",
+    [k_srjoystick_grab]  = "\x8e",
+    [k_srjoystick_look]  = "\x8e"
+   };
+
+   const char *keyboard_table[ k_srjoystick_max ] = {
+    [k_srjoystick_steer] = KEYBOARD_GLYPH( "\x93" )KEYBOARD_GLYPH( "\x95" ),
+    [k_srjoystick_grab]  = "\xa4",
+    [k_srjoystick_look]  = "\xa4"
+   };
+
+   if( vg_input.display_input_method == k_input_method_controller )
+      return controller_table[ joystick ];
+   else
+      return keyboard_table[ joystick ];
+}
+
+static int buttons_filter_fixed(void)
 {
    if( vg_console.enabled )
-      return 0;
+      return 1;
 
    if( vg.engine_stage == k_engine_stage_update_fixed )
       if( vg.fixed_iterations > 0 )
-         return 0;
+         return 1;
+
+   return 0;
+}
+
+/* Rising edge of button */
+static int button_down( enum sr_bind button )
+{
+   if( buttons_filter_fixed() )
+      return 0;
    
    if(  srinput.button_states[ button ][0] && 
        !srinput.button_states[ button ][1] )
@@ -55,14 +201,11 @@ static int button_down( enum sr_bind button )
       return 0;
 }
 
+/* Falling edge of button */
 static int button_up( enum sr_bind button )
 {
-   if( vg_console.enabled )
+   if( buttons_filter_fixed() )
       return 0;
-
-   if( vg.engine_stage == k_engine_stage_update_fixed )
-      if( vg.fixed_iterations > 0 )
-         return 0;
    
    if( !srinput.button_states[ button ][0] && 
         srinput.button_states[ button ][1] )
@@ -71,6 +214,7 @@ static int button_up( enum sr_bind button )
       return 0;
 }
 
+/* State of button */
 static int button_press( enum sr_bind button )
 {
    if( vg_console.enabled )
@@ -79,6 +223,20 @@ static int button_press( enum sr_bind button )
    return srinput.button_states[ button ][0];
 }
 
+static void joystick_state( enum sr_joystick joystick, v2f state )
+{
+   if( vg_console.enabled )
+      v2_zero( state );
+   else
+      v2_copy( srinput.joystick_states[ joystick ][0], state );
+}
+
+static float axis_state( enum sr_axis axis )
+{
+   if( vg_console.enabled ) return 0.0f;
+   else return srinput.axis_states[axis][0];
+}
+
 static void setbtn( enum sr_bind button, u8 value )
 {
    srinput.button_states[button][0] |= value;
@@ -91,6 +249,16 @@ static void skaterift_preupdate_inputs(void)
       srinput.button_states[i][0] = 0;
    }
 
+   for( u32 i=0; i<k_srjoystick_max; i++ ){
+      v2_copy( srinput.joystick_states[i][0], srinput.joystick_states[i][1] );
+      v2_zero( srinput.joystick_states[i][0] );
+   }
+
+   for( u32 i=0; i<k_sraxis_max; i++ ){
+      srinput.axis_states[i][1] = srinput.axis_states[i][0];
+      srinput.axis_states[i][0] = 0.0f;
+   }
+
    u32 mouse = SDL_GetMouseState(NULL,NULL),
        mouse1= (mouse & SDL_BUTTON(SDL_BUTTON_LEFT))? 1: 0,
        mouse2= (mouse & SDL_BUTTON(SDL_BUTTON_RIGHT))? 1: 0;
@@ -110,22 +278,32 @@ static void skaterift_preupdate_inputs(void)
    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));
 
    /* axis
     * --------------------------------------------*/
-   srinput.axis_grab = vg_getkey( SDLK_LSHIFT );
+   srinput.axis_states[ k_sraxis_grab ][0] = vg_getkey( SDLK_LSHIFT );
 
-   v2_zero( srinput.joy_steer );
-   v2_zero( srinput.joy_grab );
-   v2_zero( srinput.joy_look );
+   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_d ) ) srinput.joy_steer[0] += 1.0f;
-   if( vg_getkey( SDLK_a ) ) srinput.joy_steer[0] -= 1.0f;
-   if( vg_getkey( SDLK_w ) ) srinput.joy_steer[1] -= 1.0f;
-   if( vg_getkey( SDLK_s ) ) srinput.joy_steer[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;
+   if( vg_getkey( SDLK_RIGHT ) )
+      srinput.axis_states[ k_sraxis_mbrowse_h ][0] += 1.0f;
 
    if( vg_input.active_controller_index != -1 ){
       struct vg_controller *controller = 
@@ -144,17 +322,28 @@ static void skaterift_preupdate_inputs(void)
       setbtn( k_srbind_mright, buttons[ SDL_CONTROLLER_BUTTON_DPAD_RIGHT ] );
       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_GUIDE ] );
 
       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];
       
-      srinput.joy_steer[0] += axis[ SDL_CONTROLLER_AXIS_LEFTX ],
-      srinput.joy_steer[1] += axis[ SDL_CONTROLLER_AXIS_LEFTY ],
-      srinput.joy_look[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
-      srinput.joy_look[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
-      srinput.joy_grab[0]  += axis[ SDL_CONTROLLER_AXIS_RIGHTX ];
-      srinput.joy_grab[1]  += axis[ SDL_CONTROLLER_AXIS_RIGHTY ];
-      srinput.axis_grab    += vg_maxf( 0.0f, 
-                                    axis[ SDL_CONTROLLER_AXIS_TRIGGERRIGHT ] );
+      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 ];
 
       float lh = axis[ SDL_CONTROLLER_AXIS_LEFTX ],
             lv = axis[ SDL_CONTROLLER_AXIS_LEFTY ],
@@ -166,9 +355,8 @@ static void skaterift_preupdate_inputs(void)
       if( lv < -sensitivity ) setbtn( k_srbind_mdown, 1 );
    }
 
-   //v2_normalize_clamp( srinput.joy_steer );
-   //v2_normalize_clamp( srinput.joy_grab );
-   srinput.axis_grab = vg_minf( 1.0f, srinput.axis_grab );
+   srinput.axis_states[ k_sraxis_grab ][0] = 
+      vg_minf( 1.0f, srinput.axis_states[ k_sraxis_grab ][0] );
 }
 
 #endif /* INPUT_H */