the pain is gone

diff --git a/ent_skateshop.c b/ent_skateshop.c
index 9d31a26627888a32b29b8373c8264037ccccf550..6cf47dc69cd1fb5192d23a291b65a3c301d545bc 100644 (file)
--- a/ent_skateshop.c
+++ b/ent_skateshop.c
@@ -323,6 +323,7 @@ next_file: tinydir_next( &dir );
 
 VG_STATIC void global_skateshop_exit(void)
 {
+   vg_info( "exit skateshop\n" );
    localplayer.immobile = 0;
    global_skateshop.active = 0;
 }
@@ -439,9 +440,9 @@ VG_STATIC void global_skateshop_preupdate(void)
 
    if( global_skateshop.interface_loc <= k_skateshop_loc_page__viewing ){
 
-      gui_helper_action( NULL, "\x88 \x02\xaf\x03""browse" );
-      gui_helper_action( NULL, "\x1e\x85 \x02\xaf\x03""pick" );
-      gui_helper_action( NULL, "\x1e\x86 \x02\xaf\x03""exit" );
+      gui_helper_action( axis_display_string( k_sraxis_mbrowse_h ), "browse" );
+      gui_helper_action( button_display_string( k_srbind_maccept ), "pick" );
+      gui_helper_action( button_display_string( k_srbind_mback ), "exit" );
       
       int moved = 0;
 

diff --git a/font.h b/font.h
index 82af99a5126d81798def08996bc3679ac53c89bd..b1185f9e6800b1855dfb9474a2163deed635864b 100644 (file)
--- a/font.h
+++ b/font.h
@@ -53,7 +53,9 @@ enum efont_SRglyph{
    k_SRglyph_kbm_ctrl      = 0x9f,
    k_SRglyph_kbm_alt       = 0xa0,
    k_SRglyph_kbm_space     = 0xa1,
-   k_SRglyph_kbm_return    = 0xa2
+   k_SRglyph_kbm_return    = 0xa2,
+   k_SRglyph_kbm_escape    = 0xa3,
+   k_SRglyph_kbm_mousemove = 0xa4
 };
 
 typedef struct font3d font3d;
@@ -138,61 +140,77 @@ VG_STATIC ent_glyph *font3d_glyph( font3d *font, u32 variant_id, u32 utf32 )
    return mdl_arritm( &font->glyphs, index );
 }
 
+struct font3d_render{
+   v4f offset;
+   font3d *font;
+   const u8 *u8pch;
+   u32 variant_id;
+};
+
 VG_STATIC 
-float font3d_simple_draw( font3d *font, u32 variant_id, const char *text, 
-                         camera *cam, m4x3f transform )
+void font3d_begin( font3d *font, u32 variant_id, 
+                    camera *cam, m4x3f transform, struct font3d_render *render )
 {
-   v4f offset;
-   q_identity( offset );
+   q_identity( render->offset );
 
    m4x4f prev_mtx;
-
    m4x3_expand( transform, prev_mtx );
    m4x4_mul( cam->mtx_prev.pv, prev_mtx, prev_mtx );
 
    shader_model_font_uPvmPrev( prev_mtx );
    shader_model_font_uMdl( transform );
 
-   const u8 *u8str = (u8*)text;
+   render->font = font;
+   render->variant_id = variant_id;
+}
+
+VG_STATIC void font3d_draw( struct font3d_render *render )
+{
+   u32 max_chars = 512;
+   while( render->u8pch && max_chars ){
+      max_chars --;
 
-   for( u32 i=0;; i++ ){
-      u32 c0 = u8str[i],
-          c1;
+      u32 c0 = *render->u8pch, c1;
+      render->u8pch ++;
 
       if( !c0 ) break;
 
-      ent_glyph *glyph0 = font3d_glyph( font, variant_id, c0 ),
+      ent_glyph *glyph0 = font3d_glyph( render->font, render->variant_id, c0 ),
                 *glyph1;
 
       /* multibyte characters */
       if( c0 >= 1 && c0 < k_SRglyph_ascii_min ){
-         c1 = u8str[i+1];
+         c1 = *render->u8pch;
          if( !c1 ) break;
-         glyph1 = font3d_glyph( font, variant_id, c1 );
+         glyph1 = font3d_glyph( render->font, render->variant_id, c1 );
       }
 
       if( c0 == k_SRglyph_ctrl_variant ){
-         variant_id = c1;
-         i ++;
+         render->variant_id = c1;
+         render->u8pch ++;
          continue;
       }
       else if( c0 == k_SRglyph_ctrl_size ){
-         offset[3] = (float)c1 * (1.0f/255.0f);
-         i ++;
+         render->offset[3] = (float)c1 * (1.0f/255.0f);
+         render->u8pch ++;
          continue;
       }
       else if( c0 == k_SRglyph_ctrl_baseline ){
-         offset[1] = 0.0f;
+         render->offset[1] = 0.0f;
          continue;
       }
       else if( c0 == k_SRglyph_ctrl_center ){
-         if( glyph1 )
-            offset[1] = (glyph1->size[1] - glyph1->size[1]*offset[3]) * 0.5f;
+         if( glyph1 ){
+            float diff = glyph1->size[1] - glyph1->size[1]*render->offset[3];
+            render->offset[1] = diff * 0.5f;
+         }
          continue;
       }
       else if( c0 == k_SRglyph_ctrl_top ){
-         if( glyph1 )
-            offset[1] = glyph1->size[1] - glyph1->size[1]*offset[3];
+         if( glyph1 ){
+            float diff = glyph1->size[1] - glyph1->size[1]*render->offset[3];
+            render->offset[1] = diff;
+         }
          continue;
       }
 
@@ -201,23 +219,34 @@ float font3d_simple_draw( font3d *font, u32 variant_id, const char *text,
       if( glyph1 && (c0 == k_SRglyph_mod_square || c0 == k_SRglyph_mod_circle)){
          v4f v0;
          v2_sub( glyph0->size, glyph1->size, v0 );
-         v2_muladds( offset, v0, -0.5f, v0 );
-         v0[2] = offset[2];
-         v0[3] = offset[3];
+         v2_muladds( render->offset, v0, -0.5f, v0 );
+         v0[2] = render->offset[2];
+         v0[3] = render->offset[3];
 
          shader_model_font_uOffset( v0 );
          mesh_drawn( glyph0->indice_start, glyph0->indice_count );
          continue;
       }
       else{
-         shader_model_font_uOffset( offset );
+         shader_model_font_uOffset( render->offset );
          mesh_drawn( glyph0->indice_start, glyph0->indice_count );
       }
 
-      offset[0] += glyph0->size[0]*offset[3];
+      render->offset[0] += glyph0->size[0]*render->offset[3];
    }
 
-   return offset[0];
+   render->u8pch = NULL;
+}
+
+VG_STATIC 
+float font3d_simple_draw( font3d *font, u32 variant_id, const char *text, 
+                         camera *cam, m4x3f transform )
+{
+   struct font3d_render render;
+   font3d_begin( font, variant_id, cam, transform, &render );
+   render.u8pch = (u8*)text;
+   font3d_draw( &render );
+   return render.offset[0];
 }
 
 VG_STATIC 

diff --git a/gui.h b/gui.h
index 8cb94f1200fc0615b07f02ae72163aeff6644b09..2ec0a5070afb4640cdf97d3fbef2e8178a9c896e 100644 (file)
--- a/gui.h
+++ b/gui.h
@@ -5,8 +5,7 @@
 
 struct{
    struct gui_helper{
-      struct input_binding *bind;
-      const char *text;
+      const char *bindstr, *text;
    }
    helpers[4];
    u32 helper_count;
@@ -73,7 +72,20 @@ void gui_draw(void)
 
       shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
 
-      float w = font3d_simple_draw( font, 2, helper->text, &ortho, mmdl )+1.0f;
+      struct font3d_render render;
+      font3d_begin( font, 2, &ortho, mmdl, &render );
+
+      render.u8pch = (u8*)helper->bindstr;
+      font3d_draw( &render );
+
+      const char *make_smaller = "\x02\xaf\x03 ";
+      render.u8pch = (const u8*)make_smaller;
+      font3d_draw( &render );
+
+      render.u8pch = (u8*)helper->text;
+      font3d_draw( &render );
+      
+      float w = render.offset[0]+1.0f;
       mmdl[3][0] += w*scale;
    }
 
@@ -81,13 +93,13 @@ void gui_draw(void)
 }
 
 VG_STATIC 
-void gui_helper_action( void *bind, const char *text )
+void gui_helper_action( const char *bindstr, const char *text )
 {
    if( gui.helper_count >= vg_list_size(gui.helpers) )
       vg_fatal_error( "Too many helpers\n" );
 
    struct gui_helper *helper = &gui.helpers[ gui.helper_count ++ ];
-   helper->bind = bind;
+   helper->bindstr = bindstr;
    helper->text = text;
 }
 

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 */

diff --git a/models_src/rs_font.mdl b/models_src/rs_font.mdl
index d351fa05d65025eec693226a053d87f36669d925..bf167ad41c359b2b77924271478caf234545d6d8 100644 (file)
Binary files a/models_src/rs_font.mdl and b/models_src/rs_font.mdl differ

diff --git a/player_common.c b/player_common.c
index a2a2ab2d18771da26f56f5fabadd1b03a9aae2d0..110ee1640e33d0fd85816c44ee6d05a67a5b629d 100644 (file)
--- a/player_common.c
+++ b/player_common.c
@@ -244,8 +244,11 @@ VG_STATIC void player_look( player_instance *player, v3f angles )
       mouse_input[1] *= -1.0f;
    v2_muladds( angles, mouse_input, 0.0025f, angles );
 
-   angles[0] += srinput.joy_look[0] * vg.time_delta * 4.0f;
-   float input_y = srinput.joy_look[1] * vg.time_delta * 4.0f;
+   v2f jlook;
+   joystick_state( k_srjoystick_look, jlook );
+
+   angles[0] += jlook[0] * vg.time_delta * 4.0f;
+   float input_y = jlook[1] * vg.time_delta * 4.0f;
    if( cl_invert_y )
       input_y *= -1.0f;
 

diff --git a/player_drive.c b/player_drive.c
index 89b3f405c2b98d9a2d5b4035ca5615d975c6a9b4..2423d35189274fe859d71092ce7da8ed27ed14d5 100644 (file)
--- a/player_drive.c
+++ b/player_drive.c
@@ -9,9 +9,11 @@ VG_STATIC void player__drive_pre_update( player_instance *player )
    struct player_drive *drive = &player->_drive;
    drivable_vehicle *vehc = drive->vehicle;
 
-   vehc->steer = vg_lerpf( vehc->steer, srinput.joy_steer[0] * 0.4f,
-                           k_rb_delta * 8.0f );
-   vehc->drive = srinput.joy_steer[1];
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+
+   vehc->steer = vg_lerpf( vehc->steer, steer[0] * 0.4f, k_rb_delta * 8.0f );
+   vehc->drive = steer[1];
 }
 
 VG_STATIC void player__drive_update( player_instance *player )

diff --git a/player_skate.c b/player_skate.c
index fed00580d88dedfa414942e23710ea2b1c64f2de..d1be6b8b82c84adf3d7978e176b138e4afec7117 100644 (file)
--- a/player_skate.c
+++ b/player_skate.c
@@ -669,7 +669,7 @@ invalidated_grind:;
       }
 
       v2f steer;
-      v2_copy( srinput.joy_steer, steer ); 
+      joystick_state( k_srjoystick_steer, steer );
       v2_normalize_clamp( steer );
 
       if( (fabsf(steer[1]) > 0.5f) && (s->land_dist >= 1.5f) ){
@@ -790,7 +790,7 @@ VG_STATIC void skate_apply_grab_model( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
 
-   float grabt = srinput.axis_grab;
+   float grabt = axis_state( k_sraxis_grab );
 
    if( grabt > 0.5f ){
       v2_muladds( s->state.grab_mouse_delta, vg.mouse_delta, 0.02f, 
@@ -808,9 +808,12 @@ VG_STATIC void skate_apply_steering_model( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
 
+   v2f jsteer;
+   joystick_state( k_srjoystick_steer, jsteer );
+
    /* Steering */
-   float steer = srinput.joy_steer[0],
-         grab  = srinput.axis_grab;
+   float steer = jsteer[0],
+         grab  = axis_state( k_sraxis_grab );
 
    steer = vg_signf( steer ) * steer*steer * k_steer_ground;
 
@@ -958,7 +961,10 @@ VG_STATIC void skate_apply_jump_model( player_instance *player )
          s->grind_cooldown = 30;
          s->state.activity = k_skate_activity_ground;
 
-         float tilt  = srinput.joy_steer[0] * 0.4f;
+         v2f steer;
+         joystick_state( k_srjoystick_steer, steer );
+
+         float tilt  = steer[0] * 0.3f;
                tilt *= vg_signf(v3_dot( player->rb.v, s->grind_dir ));
 
          v4f qtilt;
@@ -989,7 +995,7 @@ VG_STATIC void skate_apply_pump_model( player_instance *player )
 
    /* Throw / collect routine 
     */
-   if( srinput.axis_grab > 0.5f ){
+   if( axis_state( k_sraxis_grab ) > 0.5f ){
       if( s->state.activity == k_skate_activity_ground ){
          /* Throw */
          v3_muls( player->rb.to_world[1], k_mmthrow_scale, s->state.throw_v );
@@ -1033,8 +1039,8 @@ VG_STATIC void skate_apply_cog_model( player_instance *player )
    v3_copy( s->state.up_dir, ideal_dir );
    v3_normalize( ideal_dir );
 
-   v3_muladds( player->rb.co, ideal_dir,
-               1.0f-srinput.axis_grab, ideal_cog );
+   float grab = axis_state( k_sraxis_grab );
+   v3_muladds( player->rb.co, ideal_dir, 1.0f-grab, ideal_cog );
    v3_sub( ideal_cog, s->state.cog, ideal_diff );
 
    /* Apply velocities */
@@ -1443,14 +1449,16 @@ VG_STATIC void skate_weight_distribute( player_instance *player )
 
    int reverse_dir = v3_dot( player->rb.to_world[2], player->rb.v ) < 0.0f?1:-1;
 
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+
    if( s->state.manual_direction == 0 ){
-      if( (srinput.joy_steer[1] > 0.7f) && 
-          (s->state.activity == k_skate_activity_ground) &&
+      if( (steer[1] > 0.7f) && (s->state.activity == k_skate_activity_ground) &&
           (s->state.jump_charge <= 0.01f) )
          s->state.manual_direction = reverse_dir;
    }
    else{
-      if( srinput.joy_steer[1] < 0.1f ){
+      if( steer[1] < 0.1f ){
          s->state.manual_direction = 0;
       }
       else{
@@ -1461,7 +1469,7 @@ VG_STATIC void skate_weight_distribute( player_instance *player )
    }
 
    if( s->state.manual_direction ){
-      float amt = vg_minf( srinput.joy_steer[1] * 8.0f, 1.0f );
+      float amt = vg_minf( steer[1] * 8.0f, 1.0f );
       s->weight_distribution[2] = k_board_length * amt * 
                                           (float)s->state.manual_direction;
    }
@@ -1614,9 +1622,10 @@ VG_STATIC void skate_grind_truck_apply( player_instance *player,
    v3_normalize( target_fwd );
    v3_normalize( fwd );
 
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
 
-   float way = srinput.joy_steer[1] *
-                  vg_signf( v3_dot( raw_nplane, player->rb.v ) );
+   float way = steer[1] * vg_signf( v3_dot( raw_nplane, player->rb.v ) );
 
    v4f q;
    q_axis_angle( q, axis, VG_PIf*0.125f * way );
@@ -1668,8 +1677,10 @@ VG_STATIC void skate_5050_apply( player_instance *player,
    v3_cross( axis, inf_avg.dir, inf_avg.n );
    skate_grind_decay( player, &inf_avg, 1.0f );
 
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
 
-   float way = srinput.joy_steer[1] *
+   float way = steer[1] *
                   vg_signf( v3_dot( player->rb.to_world[2], player->rb.v ) );
    v4f q;
    v3f up, target_up;
@@ -1963,11 +1974,14 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
    int allow_back  = 1,
        allow_front = 1;
 
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+
    if( s->state.activity == k_skate_activity_grind_5050 || 
        s->state.activity == k_skate_activity_grind_back50 ||
        s->state.activity == k_skate_activity_grind_front50 )
    {
-      float tilt = srinput.joy_steer[1];
+      float tilt = steer[1];
 
       if( fabsf(tilt) >= 0.25f ){
          v3f raw = {0.0f,0.0f,tilt};
@@ -2011,7 +2025,7 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
          res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
 
       if( res_back50 != res_front50 ){
-         int wants_to_do_that = fabsf(srinput.joy_steer[1]) >= 0.25f;
+         int wants_to_do_that = fabsf(steer[1]) >= 0.25f;
 
          res_back50  &= wants_to_do_that;
          res_front50 &= wants_to_do_that;
@@ -2763,7 +2777,10 @@ VG_STATIC void player__skate_animate( player_instance *player,
    
    mdl_keyframe air_pose[32];
    {
-      float target = -srinput.joy_steer[1];
+      v2f steer;
+      joystick_state( k_srjoystick_steer, steer );
+
+      float target = -steer[1];
 
       s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
       
@@ -2773,7 +2790,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
       static v2f grab_choice;
 
       v2f grab_input;
-      v2_copy( srinput.joy_grab, grab_input );
+      joystick_state( k_srjoystick_grab, grab_input );
       v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
 
       if( v2_length2( grab_input ) <= 0.001f )

diff --git a/player_walk.c b/player_walk.c
index 4334473e63335f8dde25db931ccfb54727d238bc..1845906e2fe01263dbddebf14bed07c860d232f0 100644 (file)
--- a/player_walk.c
+++ b/player_walk.c
@@ -382,7 +382,10 @@ VG_STATIC void player__walk_update( player_instance *player )
    m3x3_mulv( player->basis, forward_dir, forward_dir );
    m3x3_mulv( player->basis, right_dir,   right_dir );
 
-   w->move_speed = v2_length( srinput.joy_steer );
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+
+   w->move_speed = v2_length( steer );
    world_instance *world = get_active_world();
 
    /* 
@@ -424,8 +427,9 @@ VG_STATIC void player__walk_update( player_instance *player )
     */
    float accel_speed = 0.0f, nominal_speed = 0.0f;
    v3f movedir;
-   v3_muls( right_dir, srinput.joy_steer[0], movedir );
-   v3_muladds( movedir, forward_dir, srinput.joy_steer[1], movedir );
+
+   v3_muls( right_dir, steer[0], movedir );
+   v3_muladds( movedir, forward_dir, steer[1], movedir );
 
    if( w->state.activity == k_walk_activity_ground ){
       v3_normalize( surface_avg );
@@ -433,7 +437,7 @@ VG_STATIC void player__walk_update( player_instance *player )
       v3f tx, ty;
       rb_tangent_basis( surface_avg, tx, ty );
 
-      if( v2_length2(srinput.joy_steer) > 0.001f ){
+      if( v2_length2(steer) > 0.001f ){
          /* clip movement to the surface */
          float d = v3_dot(surface_avg,movedir);
          v3_muladds( movedir, surface_avg, -d, movedir );
@@ -461,7 +465,7 @@ VG_STATIC void player__walk_update( player_instance *player )
       nominal_speed = k_airspeed;
    }
 
-   if( v2_length2( srinput.joy_steer ) > 0.001f ){
+   if( v2_length2( steer ) > 0.001f ){
       player_accelerate( player->rb.v, movedir, nominal_speed, accel_speed );
       v3_normalize( movedir );
    }