menu.h

   1 #ifndef MENU_H
   2 #define MENU_H
   3
   4 #include "common.h"
   5 #include "model.h"
   6 #include "world_render.h"
   7 #include "player.h"
   8
   9 #include "shaders/menu.h"
  10 #include "vg/vg_steam_friends.h"
  11
  12 VG_STATIC mdl_context menu_model;
  13 VG_STATIC glmesh      menu_glmesh;
  14 VG_STATIC m4x3f       menu_mdl_mtx;
  15 VG_STATIC float       menu_opacity = 0.0f;
  16 VG_STATIC float       menu_input_cooldown = 0.0f;
  17 VG_STATIC float       menu_fov_target = 97.0f;
  18 VG_STATIC v2f         menu_extra_angles;
  19
  20 VG_STATIC int         menu_loc = 0xb,
  21                       menu_loc_last = 1;
  22 VG_STATIC u32         menu_page     = 0;
  23
  24 VG_STATIC int         cl_menu         = 0,
  25                       cl_menu_go_away = 0;
  26
  27 VG_STATIC int         menu_enabled(void){ return cl_menu; }
  28
  29 VG_STATIC const char *playermodels[] = { "ch_new", "ch_jordan", "ch_outlaw" };
  30
  31 vg_tex2d tex_menu = { .path = "textures/menu.qoi",.flags = VG_TEXTURE_NEAREST };
  32
  33 VG_STATIC struct input_binding input_menu_h,
  34                                input_menu_v,
  35                                input_menu_press,
  36                                input_menu_back,
  37                                input_menu_toggle,
  38                                input_menu_toggle_kbm;
  39
  40 VG_STATIC void menu_btn_paused( int event );
  41 VG_STATIC void menu_btn_quit( int event );
  42 VG_STATIC void menu_btn_skater( int event );
  43 VG_STATIC void menu_btn_map( int event );
  44 VG_STATIC void menu_btn_map_a( int event );
  45 VG_STATIC void menu_btn_map_b( int event );
  46 VG_STATIC void menu_btn_map_c( int event );
  47 VG_STATIC void menu_btn_fuckoff( int event );
  48 VG_STATIC void menu_btn_reset( int event );
  49
  50 struct menu_button
  51 {
  52    const char *name;
  53    u32 areas;
  54
  55    void (*fn_press)(int event);
  56    int links[4];
  57    mdl_node *pnode;
  58
  59    float falpha, fsize;
  60 }
  61 VG_STATIC menu_buttons[] =
  62 {
  63 /*0*/{"text_paused",     1, menu_btn_paused },
  64 /*1*/{"text_quit",       9, menu_btn_quit,    {3,-1,4,0xb}},
  65 /*2*/{"text_skater",     3, menu_btn_skater,  {3,0xb,4,-1}},
  66 /*3*/{"text_map",        5, NULL, {-1,-1,2,-1}},
  67 /*4*/{"text_about_game", 1, NULL, {2,-1,-1,-1}},
  68 /*5*/{"skater_left",     2, NULL, {-1,-1,-1,-1}},
  69 /*6*/{"skater_right",    2, NULL, {-1,-1,-1,-1}},
  70 /*7*/{"g_map",           5, NULL },
  71 /*8*/{"g_controls",      1, NULL },
  72 /*9*/{"text_quitty",     8, NULL },
  73 /*a*/{"text_yes",        8, menu_btn_fuckoff,{-1,-1,-1,-1} },
  74 /*b*/{"text_reset",      1, menu_btn_reset,{3,1,4,2} },
  75 };
  76
  77 VG_STATIC void menu_btn_map_a( int event ){}
  78 VG_STATIC void menu_btn_map_b( int event ){}
  79 VG_STATIC void menu_btn_map_c( int event ){}
  80
  81 VG_STATIC void menu_btn_paused( int event )
  82 {
  83
  84 }
  85
  86 VG_STATIC void menu_btn_reset( int event )
  87 {
  88    reset_player(0,NULL);
  89    world_routes_clear();
  90
  91    cl_menu_go_away = 1;
  92    menu_page = 0;
  93 }
  94
  95 VG_STATIC void menu_btn_fuckoff( int event )
  96 {
  97    glfwSetWindowShouldClose( vg.window, 1 );
  98 }
  99
 100 VG_STATIC void menu_btn_quit( int event )
 101 {
 102    menu_page = 0x8;
 103    menu_loc = 0xa;
 104 }
 105
 106 VG_STATIC void menu_btn_map( int event )
 107 {
 108    menu_page = 0x4;
 109    menu_loc = 7;
 110 }
 111
 112 VG_STATIC void menu_btn_skater( int event )
 113 {
 114    menu_page = 0x2;
 115 }
 116
 117
 118 VG_STATIC void steam_on_game_overlay( CallbackMsg_t *msg )
 119 {
 120    GameOverlayActivated_t *inf = (GameOverlayActivated_t *)msg->m_pubParam;
 121    vg_info( "Steam game overlay activated; pausing\n" );
 122
 123    if( inf->m_bActive )
 124    {
 125       cl_menu = 1;
 126       menu_page = 1;
 127    }
 128 }
 129
 130 VG_STATIC void menu_init(void)
 131 {
 132    vg_create_unnamed_input( &input_menu_h, k_input_type_axis );
 133    vg_create_unnamed_input( &input_menu_v, k_input_type_axis );
 134    vg_create_unnamed_input( &input_menu_back, k_input_type_button );
 135    vg_create_unnamed_input( &input_menu_press, k_input_type_button );
 136    vg_create_unnamed_input( &input_menu_toggle, k_input_type_button );
 137    vg_create_unnamed_input( &input_menu_toggle_kbm, k_input_type_button );
 138
 139    vg_apply_bind_str( &input_menu_h, "", "gp-ls-h" );
 140    vg_apply_bind_str( &input_menu_h, "+", "d" );
 141    vg_apply_bind_str( &input_menu_h, "-", "a" );
 142    vg_apply_bind_str( &input_menu_v, "", "-gp-ls-v" );
 143    vg_apply_bind_str( &input_menu_v, "+", "w" );
 144    vg_apply_bind_str( &input_menu_v, "-", "s" );
 145    vg_apply_bind_str( &input_menu_press, "", "gp-a" );
 146    vg_apply_bind_str( &input_menu_press, "", "e" );
 147    vg_apply_bind_str( &input_menu_back, "", "gp-b" );
 148    vg_apply_bind_str( &input_menu_back, "", "\2escape" );
 149    vg_apply_bind_str( &input_menu_toggle_kbm, "", "\2escape" );
 150    vg_apply_bind_str( &input_menu_toggle, "", "\2gp-menu" );
 151
 152    vg_linear_clear( vg_mem.scratch );
 153
 154    mdl_open( &menu_model, "models/rs_menu.mdl" );
 155    mdl_load_metadata( &menu_model, vg_mem.rtmemory );
 156    mdl_load_mesh_data( &menu_model, vg_mem.scratch );
 157    mdl_close( &menu_model );
 158
 159    vg_acquire_thread_sync();
 160    {
 161       mdl_unpack_glmesh( &menu_model, &menu_glmesh );
 162       vg_tex2d_init( (vg_tex2d *[]){ &tex_menu }, 1 );
 163    }
 164    vg_release_thread_sync();
 165
 166    for( int i=0; i<vg_list_size(menu_buttons); i++ )
 167    {
 168       struct menu_button *btn = &menu_buttons[i];
 169       btn->pnode = mdl_node_from_name( &menu_model, btn->name );
 170
 171       if( !btn->pnode )
 172          vg_fatal_exit_loop( "Menu programming error" );
 173    }
 174
 175    shader_menu_register();
 176
 177 #ifdef SR_NETWORKED
 178    steam_register_callback( k_iGameOverlayActivated, steam_on_game_overlay );
 179 #endif
 180 }
 181
 182 VG_STATIC void menu_run_directional(void)
 183 {
 184    struct menu_button *btn = &menu_buttons[ menu_loc ];
 185
 186    if( vg_input_button_down( &input_menu_press ) )
 187    {
 188       if( btn->fn_press )
 189       {
 190          audio_lock();
 191          audio_play_oneshot( &audio_ui[0], 1.0f );
 192          audio_unlock();
 193
 194          btn->fn_press( 1 );
 195          return;
 196       }
 197    }
 198
 199    if( menu_input_cooldown <= 0.0f )
 200    {
 201       v2f dir = {  input_menu_h.axis.value,
 202                   -input_menu_v.axis.value };
 203
 204       if( v2_length2( dir ) > 0.8f*0.8f )
 205       {
 206          int idir = 0;
 207
 208          if( fabsf(dir[0]) > fabsf(dir[1]) )
 209          {
 210             if( dir[0] > 0.0f ) idir = 2;
 211             else idir = 0;
 212          }
 213          else
 214          {
 215             if( dir[1] > 0.0f ) idir = 3;
 216             else idir = 1;
 217          }
 218
 219          int link = btn->links[idir];
 220
 221          if( link != -1 )
 222          {
 223             menu_loc_last = menu_loc;
 224             menu_loc = link;
 225             menu_input_cooldown = 0.25f;
 226          }
 227       }
 228    }
 229 }
 230
 231 VG_STATIC int menu_page_should_backout(void)
 232 {
 233    return vg_input_button_down( &input_menu_back );
 234 }
 235
 236 VG_STATIC void menu_close(void)
 237 {
 238    cl_menu_go_away = 1;
 239    menu_page = 0;
 240 }
 241
 242 VG_STATIC void menu_page_main(void)
 243 {
 244    if( menu_page_should_backout() )
 245    {
 246       menu_close();
 247       return;
 248    }
 249
 250    menu_fov_target = 112.0f;
 251    menu_run_directional();
 252 }
 253
 254 VG_STATIC void menu_page_map(void)
 255 {
 256    if( menu_page_should_backout() )
 257    {
 258       menu_page = 1;
 259       menu_loc = 3;
 260    }
 261
 262    menu_fov_target = 80.0f;
 263    menu_run_directional();
 264 }
 265
 266 VG_STATIC void menu_page_quit(void)
 267 {
 268    if( menu_page_should_backout() )
 269    {
 270       menu_page = 1;
 271       menu_loc = 1;
 272    }
 273
 274    menu_fov_target = 90.0f;
 275    menu_run_directional();
 276 }
 277
 278 VG_STATIC void menu_page_skater(void)
 279 {
 280    float h = input_menu_h.axis.value;
 281    menu_fov_target = 97.0f;
 282
 283    if( menu_page_should_backout() )
 284    {
 285       menu_page = 1;
 286       menu_loc = 2;
 287       return;
 288    }
 289
 290    if( (fabsf(h) > 0.7f) && (menu_input_cooldown <= 0.0f) )
 291    {
 292       audio_lock();
 293       audio_play_oneshot( &audio_rewind[4], 1.0f );
 294       audio_unlock();
 295
 296       if( h < 0.0f )
 297       {
 298          cl_playermdl_id --;
 299          if( cl_playermdl_id < 0 )
 300             cl_playermdl_id = 2;
 301
 302          menu_buttons[5].fsize = 0.4f;
 303          menu_buttons[5].falpha = 1.0f;
 304
 305          menu_input_cooldown = 0.25f;
 306       }
 307       else
 308       {
 309          cl_playermdl_id ++;
 310          if( cl_playermdl_id > 2 )
 311             cl_playermdl_id = 0;
 312
 313          menu_buttons[6].fsize = 0.4f;
 314          menu_buttons[6].falpha = 1.0f;
 315
 316          menu_input_cooldown = 0.25f;
 317       }
 318    }
 319 }
 320
 321 VG_STATIC void menu_update(void)
 322 {
 323    vg_input_update( 1, &input_menu_h );
 324    vg_input_update( 1, &input_menu_v );
 325    vg_input_update( 1, &input_menu_back );
 326    vg_input_update( 1, &input_menu_press );
 327    vg_input_update( 1, &input_menu_toggle );
 328    vg_input_update( 1, &input_menu_toggle_kbm );
 329
 330    int toggle_gp = vg_input_button_down( &input_menu_toggle ),
 331        toggle_kb = vg_input_button_down( &input_menu_toggle_kbm ),
 332        wait_for_a_sec = 0;
 333
 334    if( toggle_gp || toggle_kb )
 335    {
 336       if( cl_menu )
 337       {
 338          if( toggle_gp )
 339          {
 340             cl_menu_go_away = 1;
 341             menu_page = 0;
 342          }
 343       }
 344       else
 345       {
 346          if( toggle_kb )
 347             wait_for_a_sec = 1;
 348
 349          cl_menu = 1;
 350          menu_page = 1;
 351       }
 352    }
 353
 354    if( !wait_for_a_sec )
 355    {
 356       if( menu_page == 1 )
 357          menu_page_main();
 358       else if( menu_page == 2 )
 359          menu_page_skater();
 360       else if( menu_page == 4 )
 361          menu_page_map();
 362       else if( menu_page == 8 )
 363          menu_page_quit();
 364    }
 365
 366    struct menu_button *btn = &menu_buttons[ menu_loc ];
 367
 368    v3f pos;
 369    v2f angles;
 370
 371    /* Base */
 372    {
 373       v3f lookdir;
 374       v3f *mtx = player.mdl.sk.final_mtx[player.mdl.id_head];
 375       m3x3_mulv( mtx, (v3f){-1.0f,0.0f,0.0f}, lookdir );
 376
 377       lookdir[1] = 0.0f;
 378       v3_normalize( lookdir );
 379
 380       v3f center_rough;
 381
 382       if( player.is_dead )
 383       {
 384          v3_copy(player.mdl.ragdoll[ player.mdl.id_hip-1 ].rb.co, center_rough);
 385       }
 386       else
 387       {
 388          v3_add( player.camera_pos, player.visual_transform[3], center_rough );
 389          v3_muls( center_rough, 0.5f, center_rough );
 390       }
 391
 392       v3_muladds( center_rough, lookdir, 1.5f, pos );
 393       v3_add( (v3f){ 0.0f,0.8f,0.0f}, pos, pos );
 394
 395       angles[1] = 0.0f;
 396       angles[0] = -atan2f( lookdir[0], lookdir[2] );
 397
 398       /* setup model matrix */
 399       v4f qmenu_mdl;
 400       q_axis_angle( qmenu_mdl, (v3f){0.0f,1.0f,0.0f}, -angles[0] );
 401
 402       q_m3x3( qmenu_mdl, menu_mdl_mtx );
 403       v3_copy( center_rough, menu_mdl_mtx[3] );
 404    }
 405
 406    /* Extra */
 407    {
 408       v3f delta;
 409       v3_sub( btn->pnode->co, (v3f){ 0.0f,1.5f,-1.5f }, delta );
 410       v3_normalize( delta );
 411
 412       float y = atan2f( delta[0], delta[2] ),
 413             p = -sinf(delta[1]),
 414             dt = vg.frame_delta;
 415
 416       menu_extra_angles[0] = vg_lerpf( menu_extra_angles[0], y, dt );
 417       menu_extra_angles[1] = vg_lerpf( menu_extra_angles[1], p, dt );
 418
 419       v2_muladds( angles, menu_extra_angles, 0.8f, angles );
 420       angles[0] = fmodf( angles[0], VG_TAUf );
 421    }
 422
 423    /* Update camera */
 424    {
 425       camera_angles[0] = vg_alerpf( camera_angles[0], angles[0], menu_opacity );
 426       camera_angles[1] = vg_lerpf ( camera_angles[1], angles[1], menu_opacity );
 427       v3_lerp( camera_pos, pos, menu_opacity, camera_pos );
 428       camera_update();
 429    }
 430
 431    float dt = vg.frame_delta * 6.0f;
 432    menu_opacity = vg_lerpf( menu_opacity, cl_menu&&!cl_menu_go_away, dt );
 433
 434    if( menu_opacity <= 0.01f )
 435    {
 436       cl_menu = 0;
 437       cl_menu_go_away = 0;
 438    }
 439
 440    vg.time_rate = 1.0-(double)menu_opacity;
 441
 442    if( cl_menu )
 443    {
 444       menu_input_cooldown -= vg.frame_delta;
 445    }
 446 }
 447
 448 /* https://iquilezles.org/articles/functions/ */
 449 float expSustainedImpulse( float x, float f, float k )
 450 {
 451     float s = fmaxf(x-f,0.0f);
 452     return fminf( x*x/(f*f), 1.0f+(2.0f/f)*s*expf(-k*s));
 453 }
 454
 455 VG_STATIC void menu_render( m4x4f projection )
 456 {
 457    glEnable(GL_BLEND);
 458    glDisable(GL_DEPTH_TEST);
 459    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 460    glBlendEquation(GL_FUNC_ADD);
 461
 462    shader_fscolour_use();
 463    shader_fscolour_uColour( (v4f){ 0.1f, 0.1f, 0.3f, menu_opacity*0.5f } );
 464    render_fsquad();
 465
 466    glEnable( GL_DEPTH_TEST );
 467    glDisable( GL_BLEND );
 468
 469    m4x3f mtx;
 470
 471    shader_menu_use();
 472    shader_menu_uColour( (v4f){ 1.0f,1.0f,1.0f,1.0f} );
 473    shader_menu_uTexMain( 1 );
 474    vg_tex2d_bind( &tex_menu, 1 );
 475
 476    shader_menu_uPv( projection );
 477    mesh_bind( &menu_glmesh );
 478
 479    for( int i=0; i<vg_list_size(menu_buttons); i++ )
 480    {
 481       struct menu_button *btn = &menu_buttons[i];
 482       float talpha = i==menu_loc? 1.0f: 0.0f,
 483             tsize0 = btn->areas & menu_page? 1.0f: 0.0f,
 484             tsize1 = i==menu_loc? 0.07f: 0.0f,
 485             tsize  = tsize0+tsize1;
 486
 487       btn->falpha = vg_lerpf( btn->falpha, talpha, vg.frame_delta * 14.0f );
 488       btn->fsize  = vg_lerpf( btn->fsize,  tsize,  vg.frame_delta * 3.0f  );
 489
 490       /* Colour */
 491       v4f vselected = {0.95f*1.3f,0.45f*1.3f,0.095f*1.3f, 1.0f},
 492           vnormal   = {1.0f,1.0f,1.0f, 1.0f},
 493           vcurrent;
 494
 495       v4_lerp( vnormal, vselected, btn->falpha, vcurrent );
 496       shader_menu_uColour( vcurrent );
 497
 498       /* Create matrix */
 499       m4x3f mtx_size;
 500       mdl_node_transform( btn->pnode, mtx );
 501       m4x3_mul( menu_mdl_mtx, mtx, mtx );
 502       m4x3_identity( mtx_size );
 503       m4x3_scale( mtx_size, expSustainedImpulse( btn->fsize, 0.5f, 8.7f) );
 504       m4x3_mul( mtx, mtx_size, mtx );
 505       shader_menu_uMdl( mtx );
 506
 507       for( int j=0; j<btn->pnode->submesh_count; j++ )
 508       {
 509          mdl_submesh *sm =
 510             &menu_model.submesh_buffer[ btn->pnode->submesh_start+j ];
 511          mdl_draw_submesh( sm );
 512       }
 513    }
 514
 515    /*
 516    for( int i=0; i<menu_model->node_count; i++ )
 517    {
 518       mdl_node *pnode = mdl_node_from_id( menu_model, i );
 519
 520       for( int j=0; j<pnode->submesh_count; j++ )
 521       {
 522          mdl_submesh *sm =
 523             mdl_submesh_from_id( menu_model, pnode->submesh_start+j );
 524
 525          mdl_node_transform( pnode, mtx );
 526          m4x3_mul( menu_mdl_mtx, mtx, mtx );
 527          shader_menu_uMdl( mtx );
 528
 529          mdl_draw_submesh( sm );
 530       }
 531    }
 532    */
 533 }
 534
 535 #endif /* MENU_H */