s1 = c.split(factor=0.3)
c = s1.column()
row = c.row()
- lbl = chr(item.utf32) if item.utf32 >= 32 and item.utf32 <= 126 else 'ERR'
+ lbl = chr(item.utf32) if item.utf32 >= 32 and item.utf32 <= 126 else \
+ f'x{item.utf32:x}'
row.label(text=lbl)
c = s1.column()
c.prop( item, 'utf32', text='', emboss=True )
return;
}
- float h = localplayer.input_js1h->axis.value;
-
if( global_skateshop.interface_loc <= k_skateshop_loc_page__viewing ){
- if( fabsf(h) > 0.25f ){
- if( h < 0.0f ){
- if( global_skateshop.selected_registry_id > 0 )
- global_skateshop.selected_registry_id --;
+
+ 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" );
+
+ int moved = 0;
+
+ if( button_down( k_srbind_mleft ) ){
+ if( global_skateshop.selected_registry_id > 0 ){
+ global_skateshop.selected_registry_id --;
+ moved = 1;
}
- else{
- if( global_skateshop.selected_registry_id <
- global_skateshop.registry_count-1 )
- {
- global_skateshop.selected_registry_id ++;
- }
+ }
+
+ if( button_down( k_srbind_mright ) ){
+ if( global_skateshop.selected_registry_id <
+ global_skateshop.registry_count-1 )
+ {
+ global_skateshop.selected_registry_id ++;
+ moved = 1;
}
+ }
+ if( moved ){
vg_info( "Select registry: %u\n",
global_skateshop.selected_registry_id );
global_skateshop.interaction_cooldown = 0.125f;
return;
}
- if( vg_input_button_down( &input_menu_back ) ){
+ if( button_down( k_srbind_mback ) ){
global_skateshop_exit();
return;
}
-
- gui_helper_action( localplayer.input_use, "Select" );
}
}
enum efont_SRglyph{
- k_SRglyph_end = 0, /* control characters */
- k_SRglyph_ctrl_variant = 1,
+ k_SRglyph_end = 0x00, /* control characters */
+ k_SRglyph_ctrl_variant = 0x01,
+ k_SRglyph_ctrl_size = 0x02, /* normalized 0-1 */
+ k_SRglyph_ctrl_center = 0x03, /* useful when text is scaled down */
+ k_SRglyph_ctrl_baseline = 0x04, /* . */
+ k_SRglyph_ctrl_top = 0x05, /* . */
k_SRglyph_mod_circle = 0x1e, /* surround and center next charater */
k_SRglyph_mod_square = 0x1f, /* surround and center next character */
k_SRglyph_ascii_min = 0x20, /* standard ascii */
k_SRglyph_ps4_cross = 0x82,
k_SRglyph_xb1_x = 0x83,/* xbox buttons */
k_SRglyph_xb1_y = 0x84,
- k_SRglyph_xb1_b = 0x85,
- k_SRglyph_xb1_a = 0x86,
+ k_SRglyph_xb1_a = 0x85,
+ k_SRglyph_xb1_b = 0x86,
k_SRglyph_gen_ls = 0x87,/* generic gamepad */
k_SRglyph_gen_lsh = 0x88,
k_SRglyph_gen_lsv = 0x89,
k_SRglyph_kbm_shift = 0x9e,/* modifiers */
k_SRglyph_kbm_ctrl = 0x9f,
k_SRglyph_kbm_alt = 0xa0,
- k_SRglyph_kbm_space = 0xa1
+ k_SRglyph_kbm_space = 0xa1,
+ k_SRglyph_kbm_return = 0xa2
};
typedef struct font3d font3d;
mdl_async_load_glmesh( &font->mdl, &font->mesh );
vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
- VG_TEX2D_NEAREST|VG_TEX2D_REPEAT|VG_TEX2D_NOMIP,
+ VG_TEX2D_LINEAR|VG_TEX2D_CLAMP,
&font->texture );
mdl_close( &font->mdl );
float font3d_simple_draw( font3d *font, u32 variant_id, const char *text,
camera *cam, m4x3f transform )
{
- v3f offset;
- v3_zero( offset );
+ v4f offset;
+ q_identity( offset );
m4x4f prev_mtx;
const u8 *u8str = (u8*)text;
- for( int i=0;; i++ ){
- u32 c = u8str[i];
- if(!c) break;
+ for( u32 i=0;; i++ ){
+ u32 c0 = u8str[i],
+ c1;
+
+ if( !c0 ) break;
+
+ ent_glyph *glyph0 = font3d_glyph( font, variant_id, c0 ),
+ *glyph1;
+
+ /* multibyte characters */
+ if( c0 >= 1 && c0 < k_SRglyph_ascii_min ){
+ c1 = u8str[i+1];
+ if( !c1 ) break;
+ glyph1 = font3d_glyph( font, variant_id, c1 );
+ }
- if( c == k_SRglyph_ctrl_variant ){
- variant_id = u8str[i+1];
+ if( c0 == k_SRglyph_ctrl_variant ){
+ variant_id = c1;
+ i ++;
+ continue;
+ }
+ else if( c0 == k_SRglyph_ctrl_size ){
+ offset[3] = (float)c1 * (1.0f/255.0f);
+ i ++;
+ continue;
+ }
+ else if( c0 == k_SRglyph_ctrl_baseline ){
+ 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;
+ continue;
+ }
+ else if( c0 == k_SRglyph_ctrl_top ){
+ if( glyph1 )
+ offset[1] = glyph1->size[1] - glyph1->size[1]*offset[3];
continue;
}
- ent_glyph *glyph = font3d_glyph( font, variant_id, c );
- if( !glyph ) continue;
+ if( !glyph0 ) continue;
+
+ 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];
- if( glyph->indice_count ){
- if( c == k_SRglyph_mod_square || c == k_SRglyph_mod_circle ){
- u32 c1 = u8str[i+1];
- if( c1 == '\0' ) break;
-
- ent_glyph *glyph1 = font3d_glyph( font, variant_id, c1 );
-
- if( glyph1 ){
- if( glyph1->indice_count ){
- v3f v0;
- v2_sub( glyph->size, glyph1->size, v0 );
- v2_muladds( offset, v0, -0.5f, v0 );
- v0[2] = 0.0f;
-
- shader_model_font_uOffset( v0 );
- mesh_drawn( glyph->indice_start, glyph->indice_count );
-
- shader_model_font_uOffset( offset );
- mesh_drawn( glyph1->indice_start, glyph1->indice_count );
- offset[0] += glyph1->size[0];
- }
- }
-
- i ++;
- continue;
- }
- else{
- shader_model_font_uOffset( offset );
- mesh_drawn( glyph->indice_start, glyph->indice_count );
- }
+ shader_model_font_uOffset( v0 );
+ mesh_drawn( glyph0->indice_start, glyph0->indice_count );
+ continue;
}
- offset[0] += glyph->size[0];
+ else{
+ shader_model_font_uOffset( offset );
+ mesh_drawn( glyph0->indice_start, glyph0->indice_count );
+ }
+
+ offset[0] += glyph0->size[0]*offset[3];
}
return offset[0];
}
helpers[4];
u32 helper_count;
+
+ float factive;
}
static gui;
camera_update_view( &ortho );
camera_finalize( &ortho );
- if( gui.helper_count ){
+ gui.factive = vg_lerpf( gui.factive, gui.helper_count?1.0f:0.0f,
+ vg.time_delta*2.0f );
+
+ if( gui.factive > 0.01f ){
/* draw bottom bar */
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendEquation(GL_FUNC_ADD);
shader_blitcolour_use();
- shader_blitcolour_uColour( (v4f){ 0.0f, 0.0f, 0.0f, 0.8f } );
+ shader_blitcolour_uColour( (v4f){ 0.0f, 0.0f, 0.0f, gui.factive*0.8f } );
render_fsquad1();
}
- glDisable(GL_BLEND);
font3d *font = &world_global.font;
font3d_bind( font, &ortho );
v3_zero( mmdl[3] );
float pad = dy*0x1p-4f*0.125f;
- mmdl[3][0] = pad;
+ mmdl[3][0] = pad*2.0f;
mmdl[3][1] = pad;
for( u32 i=0; i<gui.helper_count; i++ ){
shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
- float w = font3d_simple_draw( font, 1, helper->text, &ortho, mmdl )+0.2f;
+ float w = font3d_simple_draw( font, 2, helper->text, &ortho, mmdl )+1.0f;
mmdl[3][0] += w*scale;
}
}
VG_STATIC
-void gui_helper_action( struct input_binding *bind, const char *text )
+void gui_helper_action( void *bind, const char *text )
{
if( gui.helper_count >= vg_list_size(gui.helpers) )
vg_fatal_error( "Too many helpers\n" );
--- /dev/null
+#ifndef INPUT_H
+#define INPUT_H
+
+#define VG_GAME
+#include "vg/vg.h"
+#include "vg/vg_platform.h"
+#include "vg/vg_console.h"
+#include "vg/vg_input.h"
+#include "vg/vg_m.h"
+#include "conf.h"
+
+enum sr_bind{
+ k_srbind_jump = 0,
+ k_srbind_push,
+ k_srbind_trick0,
+ k_srbind_trick1,
+ k_srbind_trick2,
+ k_srbind_use,
+ k_srbind_reset,
+ k_srbind_camera,
+ k_srbind_mleft,
+ k_srbind_mright,
+ k_srbind_mup,
+ k_srbind_mdown,
+ k_srbind_mback,
+ k_srbind_maccept,
+ k_srbind_max
+};
+
+struct {
+ v2f joy_steer,
+ joy_grab,
+ joy_look;
+
+ float axis_grab;
+
+ u8 button_states[ k_srbind_max ][2];
+ float repeaters[4];
+}
+static srinput;
+
+static int button_down( enum sr_bind button )
+{
+ if( vg_console.enabled )
+ 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] )
+ return 1;
+ else
+ return 0;
+}
+
+static int button_up( enum sr_bind button )
+{
+ if( vg_console.enabled )
+ 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] )
+ return 1;
+ else
+ return 0;
+}
+
+static int button_press( enum sr_bind button )
+{
+ if( vg_console.enabled )
+ return 0;
+
+ return srinput.button_states[ button ][0];
+}
+
+static void setbtn( enum sr_bind button, u8 value )
+{
+ srinput.button_states[button][0] |= value;
+}
+
+static void skaterift_preupdate_inputs(void)
+{
+ 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;
+ }
+
+ u32 mouse = SDL_GetMouseState(NULL,NULL),
+ 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_mup, vg_getkey(SDLK_UP) );
+ setbtn( k_srbind_mdown, vg_getkey(SDLK_DOWN) );
+ setbtn( k_srbind_mback, 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 );
+
+ v2_zero( srinput.joy_steer );
+ v2_zero( srinput.joy_grab );
+ v2_zero( srinput.joy_look );
+
+ 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_input.active_controller_index != -1 ){
+ 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_mup, buttons[ SDL_CONTROLLER_BUTTON_DPAD_UP ] );
+ setbtn( k_srbind_mdown, buttons[ SDL_CONTROLLER_BUTTON_DPAD_DOWN ] );
+
+ float *axis = controller->axises;
+
+ 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 ] );
+
+ 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_mup, 1 );
+ 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 );
+}
+
+#endif /* INPUT_H */
GLuint tex_menu;
+#if 0
VG_STATIC struct input_binding input_menu_h,
input_menu_v,
input_menu_press,
input_menu_back,
input_menu_toggle,
input_menu_toggle_kbm;
+#endif
VG_STATIC void menu_btn_quit( int event );
VG_STATIC void menu_btn_skater( int event );
return 0;
}
+#if 0
VG_STATIC int menu_controller( struct menu_btn_userdata ud )
{
if( (game_menu.page & (k_menu_page_main|k_menu_page_settings))
return 1;
return 0;
}
+#endif
struct menu_button
{
{
"res_info", menu_vis, {k_menu_page_settings},
},
+#if 0
{ "ctr_xbox", menu_controller_inf, {k_steam_controller_type_xbox}},
{ "ctr_xbox_text", menu_controller_inf, {k_steam_controller_type_xbox}},
{ "ctr_steam", menu_controller_inf, {k_steam_controller_type_steam}},
{ "ctr_ps_text", menu_controller_inf, {k_steam_controller_type_playstation}},
{ "ctr_kbm", menu_controller_inf, {k_steam_controller_type_keyboard}},
{ "ctr_kbm_text", menu_controller_inf, {k_steam_controller_type_keyboard}},
+#endif
{
"text_paused", menu_vis, {k_menu_page_main}
},
VG_STATIC void menu_init(void)
{
- vg_create_unnamed_input( &input_menu_h, k_input_type_axis );
- vg_create_unnamed_input( &input_menu_v, k_input_type_axis );
- vg_create_unnamed_input( &input_menu_back, k_input_type_button );
- vg_create_unnamed_input( &input_menu_press, k_input_type_button );
- vg_create_unnamed_input( &input_menu_toggle, k_input_type_button );
- vg_create_unnamed_input( &input_menu_toggle_kbm, k_input_type_button );
-
+#if 0
vg_apply_bind_str( &input_menu_h, "", "gp-ls-h" );
vg_apply_bind_str( &input_menu_h, "+", "right" );
vg_apply_bind_str( &input_menu_h, "-", "left" );
vg_apply_bind_str( &input_menu_back, "", "\2escape" );
vg_apply_bind_str( &input_menu_toggle_kbm, "", "\2escape" );
vg_apply_bind_str( &input_menu_toggle, "", "\2gp-menu" );
+#endif
vg_linear_clear( vg_mem.scratch );
VG_STATIC void menu_run_directional(void)
{
+#if 0
struct menu_button *btn = &menu_buttons[ game_menu.loc ];
if( vg_input_button_down( &input_menu_press ) ){
}
}
}
+#endif
}
VG_STATIC int menu_page_should_backout(void)
{
+ return 0;
+#if 0
return vg_input_button_down( &input_menu_back );
+#endif
}
VG_STATIC void menu_close(void)
}
if( game_menu.map_count > 0 ){
+#if 0
float v = input_menu_v.axis.value;
if( (fabsf(v) > 0.7f) && (menu_input_cooldown <= 0.0f) ){
audio_lock();
menu_close();
#endif
}
+#endif
}
menu_fov_target = 80.0f;
void temp_update_playermodel(void);
VG_STATIC void menu_page_skater(void)
{
+#if 0
float h = input_menu_h.axis.value;
menu_fov_target = 97.0f;
temp_update_playermodel();
}
+#endif
}
VG_STATIC void menu_slider( float *value, int set_value,
mdl_mesh *slider, v3f co_min, v3f co_max )
{
+#if 0
if( set_value ){
float h = input_menu_h.axis.value;
if( fabsf(h) > 0.04f )
}
v3_lerp( co_min, co_max, *value, slider->transform.co );
+#endif
}
VG_STATIC void menu_page_settings(void)
VG_STATIC void menu_update(void)
{
+#if 0
vg_input_update( 1, &input_menu_h );
vg_input_update( 1, &input_menu_v );
vg_input_update( 1, &input_menu_back );
vg_input_update( 1, &input_menu_press );
vg_input_update( 1, &input_menu_toggle );
vg_input_update( 1, &input_menu_toggle_kbm );
+#endif
return;
+
+#if 0
int toggle_gp = vg_input_button_down( &input_menu_toggle ),
toggle_kb = vg_input_button_down( &input_menu_toggle_kbm ),
wait_for_a_sec = 0;
if( cl_menu ){
menu_input_cooldown -= vg.time_frame_delta;
}
+#endif
}
/* https://iquilezles.org/articles/functions/ */
#include "player.h"
#include "camera.h"
#include "player_model.h"
+#include "input.h"
VG_STATIC int localplayer_cmd_respawn( int argc, const char *argv[] )
{
assert( only_once == 0 );
only_once ++;
- inst->input_js1h = vg_create_named_input( "steer-h", k_input_type_axis );
- inst->input_js1v = vg_create_named_input( "steer-v", k_input_type_axis );
- inst->input_grab = vg_create_named_input( "grab", k_input_type_axis_norm);
- inst->input_js2h = vg_create_named_input( "grab-h", k_input_type_axis );
- inst->input_js2v = vg_create_named_input( "grab-v", k_input_type_axis );
- inst->input_jump = vg_create_named_input( "jump", k_input_type_button );
- inst->input_push = vg_create_named_input( "push", k_input_type_button );
- inst->input_walk = vg_create_named_input( "walk", k_input_type_button );
- inst->input_walkh= vg_create_named_input( "walk-h", k_input_type_axis );
- inst->input_walkv= vg_create_named_input( "walk-v", k_input_type_axis );
- inst->input_use = vg_create_named_input( "use", k_input_type_button );
- inst->input_reset= vg_create_named_input( "reset", k_input_type_button );
- inst->input_camera=vg_create_named_input( "camera", k_input_type_button );
- inst->input_trick0=vg_create_named_input( "trick0", k_input_type_button );
- inst->input_trick1=vg_create_named_input( "trick1", k_input_type_button );
- inst->input_trick2=vg_create_named_input( "trick2", k_input_type_button );
-
- const char *default_cfg[] =
- {
- "bind steer-h gp-ls-h",
- "bind -steer-h a",
- "bind +steer-h d",
-
- "bind steer-v gp-ls-v",
- "bind -steer-v w",
- "bind +steer-v s",
-
- "bind grab gp-rt",
- "bind +grab shift",
- "bind grab-h gp-rs-h",
- "bind grab-v gp-rs-v",
-
- "bind jump space",
- "bind jump gp-a",
-
- "bind trick0 mouse1",
- "bind trick0 gp-a",
- "bind trick1 mouse2",
- "bind trick1 gp-b",
- "bind trick2 gp-x", /* keyboard: m0 + m1 */
-
- "bind push gp-b",
- "bind push w",
-
- "bind walk shift",
- "bind walk gp-ls",
-
- "bind walk-h gp-ls-h",
- "bind walk-v -gp-ls-v",
- "bind +walk-h d",
- "bind -walk-h a",
- "bind +walk-v w",
- "bind -walk-v s",
-
- "bind reset gp-lb",
- "bind reset r",
-
- "bind use gp-y",
- "bind use e",
- "bind camera c",
- "bind camera gp-rb"
- };
-
- for( int i=0; i<vg_list_size(default_cfg); i++ )
- vg_execute_console_input(default_cfg[i]);
-
v3_zero( inst->rb.co );
v3_zero( inst->rb.w );
v3_zero( inst->rb.v );
return;
}
- if( vg_input_button_down( player->input_reset ) && !player->immobile ){
+ if( button_down( k_srbind_reset ) && !player->immobile ){
double delta = world_global.time - world_global.last_use;
if( (delta <= RESET_MAX_TIME) && (world_global.last_use != 0.0) ){
}
}
- if( vg_input_button_down( player->input_camera ) && !player->immobile ){
+ if( button_down( k_srbind_camera ) && !player->immobile ){
if( player->camera_mode == k_cam_firstperson )
player->camera_mode = k_cam_thirdperson;
else
ent_gate *gate_waiting;
- /*
- * Input TODO: move this
- * --------------------------------
- */
- struct input_binding *input_js1h,
- *input_js1v,
- *input_js2h,
- *input_js2v,
- *input_jump,
- *input_push,
- *input_trick0,
- *input_trick1,
- *input_trick2,
- *input_walk,
- *input_walkh,
- *input_walkv,
- *input_use,
- *input_reset,
- *input_grab,
- *input_camera;
-
int immobile;
/*
#include "player.h"
#include "conf.h"
+#include "input.h"
VG_STATIC float
k_cam_spring = 20.0f,
mouse_input[1] *= -1.0f;
v2_muladds( angles, mouse_input, 0.0025f, angles );
- if( vg_input.controller_should_use_trackpad_look ){
- static v2f last_input;
- static v2f vel;
- static v2f vel_smooth;
-
- v2f input = { player->input_js2h->axis.value,
- player->input_js2v->axis.value };
-
- if( cl_invert_y )
- input[1] *= -1.0f;
-
- if( (v2_length2(last_input) > 0.001f) && (v2_length2(input) > 0.001f) ){
- v2_sub( input, last_input, vel );
- v2_muls( vel, 1.0f/vg.time_delta, vel );
- }
- else{
- v2_zero( vel );
- }
-
- v2_lerp( vel_smooth, vel, vg.time_delta*8.0f, vel_smooth );
-
- v2_muladds( angles, vel_smooth, vg.time_delta, angles );
- v2_copy( input, last_input );
- }
- else{
- angles[0] += player->input_js2h->axis.value * vg.time_delta * 4.0f;
-
- float input_y = player->input_js2v->axis.value * vg.time_delta * 4.0f;
- if( cl_invert_y )
- input_y *= -1.0f;
+ angles[0] += srinput.joy_look[0] * vg.time_delta * 4.0f;
+ float input_y = srinput.joy_look[1] * vg.time_delta * 4.0f;
+ if( cl_invert_y )
+ input_y *= -1.0f;
- angles[1] += input_y;
- }
+ angles[1] += input_y;
angles[1] = vg_clampf( angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
}
#define PLAYER_DRIVE_C
#include "player.h"
+#include "input.h"
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,
- player->input_walkh->axis.value * 0.4f,
+ vehc->steer = vg_lerpf( vehc->steer, srinput.joy_steer[0] * 0.4f,
k_rb_delta * 8.0f );
- vehc->drive = player->input_walkv->axis.value;
+ vehc->drive = srinput.joy_steer[1];
}
VG_STATIC void player__drive_update( player_instance *player )
v3_copy( best->v, player->rb.v );
s->land_dist = best->land_dist;
- v2f steer = { player->input_js1h->axis.value,
- player->input_js1v->axis.value };
- v2_normalize_clamp( steer );
s->state.gravity_bias = best->gravity;
if( best->type == k_prediction_grind ){
s->state.activity = k_skate_activity_air_to_grind;
}
+ v2f steer;
+ v2_copy( srinput.joy_steer, steer );
+ v2_normalize_clamp( steer );
+
if( (fabsf(steer[1]) > 0.5f) && (s->land_dist >= 1.5f) ){
s->state.flip_rate = (1.0f/s->land_dist) * vg_signf(steer[1]) *
s->state.reverse ;
q_axis_angle( correction, axis,
acosf(angle)*2.0f*VG_TIMESTEP_FIXED );
q_mul( correction, player->rb.q, player->rb.q );
-
- v2f steer = { player->input_js1h->axis.value,
- player->input_js1v->axis.value };
- v2_normalize_clamp( steer );
}
VG_STATIC int player_skate_trick_input( player_instance *player );
{
struct player_skate *s = &player->_skate;
- float grabt = player->input_grab->axis.value;
+ float grabt = srinput.axis_grab;
if( grabt > 0.5f ){
v2_muladds( s->state.grab_mouse_delta, vg.mouse_delta, 0.02f,
struct player_skate *s = &player->_skate;
/* Steering */
- float steer = player->input_js1h->axis.value,
- grab = player->input_grab->axis.value;
+ float steer = srinput.joy_steer[0],
+ grab = srinput.axis_grab;
steer = vg_signf( steer ) * steer*steer * k_steer_ground;
/* Pushing additive force */
- if( !player->input_jump->button.value ){
- if( player->input_push->button.value ||
- (vg.time-s->state.start_push<0.75) )
+ if( !button_press( k_srbind_jump ) ){
+ if( button_press( k_srbind_push ) || (vg.time-s->state.start_push<0.75) )
{
if( (vg.time - s->state.cur_push) > 0.25 )
s->state.start_push = vg.time;
{
struct player_skate *s = &player->_skate;
int charging_jump_prev = s->state.charging_jump;
- s->state.charging_jump = player->input_jump->button.value;
+ s->state.charging_jump = button_press( k_srbind_jump );
/* Cannot charge this in air */
if( s->state.activity <= k_skate_activity_air_to_grind ){
s->grind_cooldown = 30;
s->state.activity = k_skate_activity_ground;
- float tilt = player->input_js1h->axis.value * 0.3f;
+ float tilt = srinput.joy_steer[0] * 0.4f;
tilt *= vg_signf(v3_dot( player->rb.v, s->grind_dir ));
v4f qtilt;
s->state.jump_charge = 0.0f;
s->state.jump_time = vg.time;
- v2f steer = { player->input_js1h->axis.value,
- player->input_js1v->axis.value };
- v2_normalize_clamp( steer );
-
audio_lock();
audio_oneshot_3d( &audio_jumps[rand()%2], player->rb.co, 40.0f, 1.0f );
audio_unlock();
/* Throw / collect routine
*/
- if( player->input_grab->axis.value > 0.5f ){
+ if( srinput.axis_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 );
v3_normalize( ideal_dir );
v3_muladds( player->rb.co, ideal_dir,
- 1.0f-player->input_grab->axis.value, ideal_cog );
+ 1.0f-srinput.axis_grab, ideal_cog );
v3_sub( ideal_cog, s->state.cog, ideal_diff );
/* Apply velocities */
VG_STATIC int player_skate_trick_input( player_instance *player )
{
- return (player->input_trick0->button.value) |
- (player->input_trick1->button.value << 1) |
- (player->input_trick2->button.value << 1) |
- (player->input_trick2->button.value);
+ return (button_press( k_srbind_trick0 ) ) |
+ (button_press( k_srbind_trick1 ) << 1) |
+ (button_press( k_srbind_trick2 ) << 1) |
+ (button_press( k_srbind_trick2 ) );
}
VG_STATIC void player__skate_pre_update( player_instance *player )
{
struct player_skate *s = &player->_skate;
- if( vg_input_button_down( player->input_use ) ){
+ if( button_down( k_srbind_use ) ){
player->subsystem = k_player_subsystem_walk;
v3f angles;
int reverse_dir = v3_dot( player->rb.to_world[2], player->rb.v ) < 0.0f?1:-1;
if( s->state.manual_direction == 0 ){
- if( (player->input_js1v->axis.value > 0.7f) &&
+ if( (srinput.joy_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( player->input_js1v->axis.value < 0.1f ){
+ if( srinput.joy_steer[1] < 0.1f ){
s->state.manual_direction = 0;
}
else{
}
if( s->state.manual_direction ){
- float amt = vg_minf( player->input_js1v->axis.value * 8.0f, 1.0f );
+ float amt = vg_minf( srinput.joy_steer[1] * 8.0f, 1.0f );
s->weight_distribution[2] = k_board_length * amt *
(float)s->state.manual_direction;
}
v3_normalize( fwd );
- float way = player->input_js1v->axis.value *
+ float way = srinput.joy_steer[1] *
vg_signf( v3_dot( raw_nplane, player->rb.v ) );
v4f q;
skate_grind_decay( player, &inf_avg, 1.0f );
- float way = player->input_js1v->axis.value *
+ float way = srinput.joy_steer[1] *
vg_signf( v3_dot( player->rb.to_world[2], player->rb.v ) );
v4f q;
v3f up, target_up;
s->state.activity == k_skate_activity_grind_back50 ||
s->state.activity == k_skate_activity_grind_front50 )
{
- float tilt = player->input_js1v->axis.value;
+ float tilt = srinput.joy_steer[1];
if( fabsf(tilt) >= 0.25f ){
v3f raw = {0.0f,0.0f,tilt};
m3x3_mulv( player->rb.to_world, raw, raw );
- float way = player->input_js1v->axis.value *
- vg_signf( v3_dot( raw, player->rb.v ) );
+ float way = tilt * vg_signf( v3_dot( raw, player->rb.v ) );
if( way < 0.0f ) allow_front = 0;
else allow_back = 0;
res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
if( res_back50 != res_front50 ){
- int wants_to_do_that = fabsf(player->input_js1v->axis.value) >= 0.25f;
+ int wants_to_do_that = fabsf(srinput.joy_steer[1]) >= 0.25f;
res_back50 &= wants_to_do_that;
res_front50 &= wants_to_do_that;
mdl_keyframe air_pose[32];
{
- float target = -player->input_js1h->axis.value;
+ float target = -srinput.joy_steer[1];
s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
static v2f grab_choice;
- v2f grab_input = { player->input_js2h->axis.value,
- player->input_js2v->axis.value };
+ v2f grab_input;
+ v2_copy( srinput.joy_grab, grab_input );
v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
+
if( v2_length2( grab_input ) <= 0.001f )
grab_input[0] = -1.0f;
else
#define PLAYER_WALK_C
#include "player.h"
+#include "input.h"
VG_STATIC void player_walk_drop_in_vector( player_instance *player, v3f vec )
{
return;
}
}
- else if( vg_input_button_down( player->input_use ) && !player->immobile ){
+ else if( button_down( k_srbind_use ) && !player->immobile ){
if( v3_dist2( player->rb.co, gzoomer.obj.rb.co ) <= 4.0f*4.0f ){
player->subsystem = k_player_subsystem_drive;
}
float yaw = player->angles[0];
- v3f forward_dir = { sinf(yaw), 0.0f, -cosf(yaw) };
- v3f right_dir = { -forward_dir[2], 0.0f, forward_dir[0] };
+ v3f forward_dir = { -sinf(yaw), 0.0f, cosf(yaw) };
+ v3f right_dir = { forward_dir[2], 0.0f, -forward_dir[0] };
m3x3_mulv( player->basis, forward_dir, forward_dir );
m3x3_mulv( player->basis, right_dir, right_dir );
-
- v2f walk = { player->input_walkh->axis.value,
- player->input_walkv->axis.value };
-
- if( v2_length2(walk) > 0.001f )
- v2_normalize_clamp( walk );
-
- w->move_speed = v2_length( walk );
+ w->move_speed = v2_length( srinput.joy_steer );
world_instance *world = get_active_world();
/*
*/
float accel_speed = 0.0f, nominal_speed = 0.0f;
v3f movedir;
- v3_muls( right_dir, walk[0], movedir );
- v3_muladds( movedir, forward_dir, walk[1], movedir );
+ v3_muls( right_dir, srinput.joy_steer[0], movedir );
+ v3_muladds( movedir, forward_dir, srinput.joy_steer[1], movedir );
if( w->state.activity == k_walk_activity_ground ){
v3_normalize( surface_avg );
v3f tx, ty;
rb_tangent_basis( surface_avg, tx, ty );
- if( v2_length2(walk) > 0.001f ){
+ if( v2_length2(srinput.joy_steer) > 0.001f ){
/* clip movement to the surface */
float d = v3_dot(surface_avg,movedir);
v3_muladds( movedir, surface_avg, -d, movedir );
nominal_speed = k_walkspeed;
/* jump */
- if( player->input_jump->button.value ){
+ if( button_down( k_srbind_jump ) ){
float d = v3_dot( player->basis[1], player->rb.v );
v3_muladds( player->rb.v, player->basis[1], -d, player->rb.v );
v3_muladds( player->rb.v, player->basis[1], 5.0f, player->rb.v );
nominal_speed = k_airspeed;
}
- if( v2_length2(walk) > 0.001f ){
+ if( v2_length2( srinput.joy_steer ) > 0.001f ){
player_accelerate( player->rb.v, movedir, nominal_speed, accel_speed );
v3_normalize( movedir );
}
rate = 9.0f;
w->blend_fly = vg_lerpf( w->blend_fly, fly, rate*vg.time_delta );
- w->blend_run = vg_lerpf( w->blend_run,
- w->move_speed *
- (1.0f + player->input_walk->button.value*0.5f),
- 2.0f*vg.time_delta );
+ w->blend_run = vg_lerpf( w->blend_run, w->move_speed, 2.0f*vg.time_delta);
}
player_pose apose, bpose;
void main()
{
compute_motion_vectors();
- vec4 diffuse = texture( uTexMain, aUv );
- FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;
+ FragColor = texture( uTexMain, aUv ) * uColour;
}
"uniform mat4x3 uMdl;\n"
"uniform mat4 uPv;\n"
"uniform mat4 uPvmPrev;\n"
-"uniform vec3 uOffset;\n"
+"uniform vec4 uOffset;\n"
"\n"
"out vec4 aColour;\n"
"out vec2 aUv;\n"
"\n"
"void main()\n"
"{\n"
-" vec3 co = a_co+uOffset;\n"
+" vec3 co = a_co*uOffset.w+uOffset.xyz;\n"
" vec3 world_pos0 = uMdl * vec4( co, 1.0 );\n"
" vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );\n"
" vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );\n"
"void main()\n"
"{\n"
" compute_motion_vectors();\n"
-" vec4 diffuse = texture( uTexMain, aUv );\n"
-" FragColor = vec4( diffuse.rgb, 1.0 ) * uColour;\n"
+" FragColor = texture( uTexMain, aUv ) * uColour;\n"
"}\n"
""},
};
static void shader_model_font_uPvmPrev(m4x4f m){
glUniformMatrix4fv(_uniform_model_font_uPvmPrev,1,GL_FALSE,(float*)m);
}
-static void shader_model_font_uOffset(v3f v){
- glUniform3fv(_uniform_model_font_uOffset,1,v);
+static void shader_model_font_uOffset(v4f v){
+ glUniform4fv(_uniform_model_font_uOffset,1,v);
}
static void shader_model_font_uTexMain(int i){
glUniform1i(_uniform_model_font_uTexMain,i);
uniform mat4x3 uMdl;
uniform mat4 uPv;
uniform mat4 uPvmPrev;
-uniform vec3 uOffset;
+uniform vec4 uOffset;
out vec4 aColour;
out vec2 aUv;
void main()
{
- vec3 co = a_co+uOffset;
+ vec3 co = a_co*uOffset.w+uOffset.xyz;
vec3 world_pos0 = uMdl * vec4( co, 1.0 );
vec4 vproj0 = uPv * vec4( world_pos0, 1.0 );
vec4 vproj1 = uPvmPrev * vec4( co, 1.0 );
{
steam_update();
+ skaterift_preupdate_inputs();
+
if( skaterift_status == 1 ){
draw_origin_axis();
network_update();
world_update( get_active_world(), localplayer.rb.co );
audio_ambient_sprites_update( get_active_world(), localplayer.rb.co );
- gui_helper_action( localplayer.input_use, "\x7f Hello \x1f""A \x1e\x84" );
+ //gui_helper_action( localplayer.input_use, "\x7f Hello \x1f""A \x1e\x84" );
}
}
#include "vg/vg_steam_user_stats.h"
#include "submodules/anyascii/impl/c/anyascii.c"
-enum steam_controller_type{
- k_steam_controller_type_keyboard,
- k_steam_controller_type_xbox,
- k_steam_controller_type_playstation,
- k_steam_controller_type_steam,
- k_steam_controller_type_steam_deck
-};
-
-VG_STATIC enum steam_controller_type steam_display_controller;
-
/*
* We only want to use steamworks if building for the networked version,
* theres not much point otherwise. We mainly want steamworks for setting
}
}
-VG_STATIC ISteamInput *steam_hInput;
-
VG_STATIC u32 utf8_byte0_byte_count( u8 char0 )
{
for( u32 k=2; k<4; k++ ){
vg_console_reg_cmd( "ach_clear_all", steam_clear_all_achievements, NULL );
vg_console_reg_cmd( "ach_set", steam_set_achievemnt_test, NULL );
- steam_hInput = SteamAPI_SteamInput();
- SteamAPI_ISteamInput_Init( steam_hInput, 0 );
- SteamAPI_ISteamInput_RunFrame( steam_hInput, 0 );
-
#endif
/* TODO: On username update callback */
{
if( steam_ready ){
steamworks_event_loop( hSteamClientPipe );
-
- /* TODO
- * We can probably request this from SDL too
- */
- if( steam_hInput ){
- SteamAPI_ISteamInput_RunFrame( steam_hInput, 0 );
-
- InputHandle_t joy0 = SteamAPI_ISteamInput_GetControllerForGamepadIndex(
- steam_hInput, 0 );
-
- vg_input.controller_should_use_trackpad_look = 0;
- if( joy0 != 0 ){
- ESteamInputType type = SteamAPI_ISteamInput_GetInputTypeForHandle(
- steam_hInput, joy0 );
-
- if( type == k_ESteamInputType_SteamController ){
- vg_input.controller_should_use_trackpad_look = 1;
- steam_display_controller = k_steam_controller_type_steam;
- }
- else if( type == k_ESteamInputType_SteamDeckController ){
- steam_display_controller = k_steam_controller_type_steam_deck;
- }
- else if( type == k_ESteamInputType_PS3Controller ||
- type == k_ESteamInputType_PS4Controller ||
- type == k_ESteamInputType_PS5Controller )
- {
- steam_display_controller = k_steam_controller_type_playstation;
- }
- else if( type == k_ESteamInputType_XBox360Controller ||
- type == k_ESteamInputType_XBoxOneController )
- {
- steam_display_controller = k_steam_controller_type_xbox;
- }
- else{
- /* currently unsupported controller */
- steam_display_controller = k_steam_controller_type_xbox;
- }
- }
- else
- steam_display_controller = k_steam_controller_type_keyboard;
- }
}
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff