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 #define CUTE_FILES_IMPLEMENTATION
  13 #include "vg/dep/randygaul/cute_files.h"
  14
  15 VG_STATIC mdl_context menu_model;
  16 VG_STATIC glmesh      menu_glmesh;
  17 VG_STATIC m4x3f       menu_mdl_mtx;
  18 VG_STATIC float       menu_opacity = 0.0f;
  19 VG_STATIC float       menu_input_cooldown = 0.0f;
  20 VG_STATIC float       menu_fov_target = 97.0f;
  21 VG_STATIC v2f         menu_extra_angles;
  22
  23 VG_STATIC int         cl_menu         = 0,
  24                       cl_menu_go_away = 0;
  25
  26 VG_STATIC int         menu_enabled(void){ return cl_menu; }
  27
  28 VG_STATIC const char *playermodels[] = { "ch_new", "ch_jordan", "ch_outlaw" };
  29
  30 vg_tex2d tex_menu = { .path = "textures/menu.qoi",.flags = VG_TEXTURE_NEAREST };
  31
  32 VG_STATIC struct input_binding input_menu_h,
  33                                input_menu_v,
  34                                input_menu_press,
  35                                input_menu_back,
  36                                input_menu_toggle,
  37                                input_menu_toggle_kbm;
  38
  39 VG_STATIC void menu_btn_quit( int event );
  40 VG_STATIC void menu_btn_skater( int event );
  41 VG_STATIC void menu_btn_fuckoff( int event );
  42 VG_STATIC void menu_btn_reset( int event );
  43 VG_STATIC void menu_btn_map( int event );
  44 VG_STATIC void menu_btn_settings( int event );
  45
  46 VG_STATIC mdl_node *menu_pnode_fov_slider,
  47                    *menu_pnode_fov_min,
  48                    *menu_pnode_fov_max;
  49
  50 struct
  51 {
  52    /* state */
  53    int loc;
  54    u32 page;
  55
  56    /* map browser */
  57    struct menu_map_file
  58    {
  59       char name[ 64 ];
  60    }
  61    maps_list[ 16 ];
  62
  63    int selected_map,
  64        map_count;
  65 }
  66 VG_STATIC game_menu;
  67
  68 enum menu_page
  69 {
  70    k_menu_page_main     = 0x1,
  71    k_menu_page_skater   = 0x2,
  72    k_menu_page_quit     = 0x4,
  73    k_menu_page_settings = 0x8,
  74    k_menu_page_map      = 0x10
  75 };
  76
  77 VG_STATIC int menu_vis( int group_mask )
  78 {
  79    if( group_mask & game_menu.page )
  80       return 1;
  81    else
  82       return 0;
  83 }
  84
  85 VG_STATIC int menu_controller( int ctr )
  86 {
  87    if( (game_menu.page & (k_menu_page_main|k_menu_page_settings))
  88          && (ctr == menu_display_controller) )
  89       return 1;
  90    return 0;
  91 }
  92
  93 VG_STATIC int menu_controller_inf( int ctr )
  94 {
  95    if( (game_menu.page & k_menu_page_settings) && (ctr == menu_display_controller) )
  96       return 1;
  97    return 0;
  98 }
  99
 100 struct menu_button
 101 {
 102    const char *name;
 103
 104    int (*fn_visibility)( int user );
 105    int   user;
 106
 107    void (*fn_press)( int event );
 108
 109    const char *ll,
 110               *lu,
 111               *lr,
 112               *ld;
 113
 114    mdl_node *pnode;
 115    float falpha, fsize;
 116 }
 117 VG_STATIC menu_buttons[] =
 118 {
 119 {
 120    "text_quit", menu_vis, k_menu_page_main|k_menu_page_quit,
 121    .fn_press = menu_btn_quit,
 122       .ld="text_reset", .lr="text_settings", .ll="text_map"
 123 },
 124    {
 125       "text_quitty", menu_vis, k_menu_page_quit
 126    },
 127    {
 128       "text_yes", menu_vis, k_menu_page_quit,
 129          .fn_press = menu_btn_fuckoff
 130    },
 131 {
 132    "text_reset", menu_vis, k_menu_page_main,
 133    .fn_press = menu_btn_reset,
 134       .lu="text_quit", .ld="text_skater", .ll="text_map", .lr="text_settings"
 135 },
 136 {
 137    "text_skater", menu_vis, k_menu_page_main|k_menu_page_skater,
 138    .fn_press = menu_btn_skater,
 139       .lu="text_reset", .ll="text_map", .lr="text_settings"
 140 },
 141 {
 142    "text_map", menu_vis, k_menu_page_main,
 143    .fn_press = menu_btn_map,
 144       .lr="text_skater"
 145 },
 146 {
 147    "text_settings", menu_vis, k_menu_page_main|k_menu_page_settings,
 148    .fn_press = menu_btn_settings,
 149       .ll="text_skater"
 150 },
 151 {
 152    "skater_left", menu_vis, k_menu_page_skater
 153 },
 154 {
 155    "skater_right", menu_vis, k_menu_page_skater
 156 },
 157
 158 { "fov_slider",      menu_vis, k_menu_page_settings },
 159 { "fov_info",        menu_vis, k_menu_page_settings },
 160
 161 { "ctr_xbox",        menu_controller_inf, k_menu_controller_type_xbox, },
 162 { "ctr_xbox_text",   menu_controller_inf, k_menu_controller_type_xbox },
 163 { "ctr_steam",       menu_controller_inf, k_menu_controller_type_steam },
 164 { "ctr_steam_text",  menu_controller_inf, k_menu_controller_type_steam },
 165 { "ctr_deck",        menu_controller_inf, k_menu_controller_type_steam_deck },
 166 { "ctr_deck_text",   menu_controller_inf, k_menu_controller_type_steam_deck },
 167 { "ctr_ps",          menu_controller_inf, k_menu_controller_type_playstation },
 168 { "ctr_ps_text",     menu_controller_inf, k_menu_controller_type_playstation },
 169 { "ctr_kbm",         menu_controller_inf, k_menu_controller_type_keyboard },
 170 { "ctr_kbm_text",    menu_controller_inf, k_menu_controller_type_keyboard },
 171 {
 172    "text_paused", menu_vis, k_menu_page_main
 173 },
 174 };
 175
 176 VG_STATIC int menu_get_loc( const char *loc )
 177 {
 178    for( int i=0; i<vg_list_size(menu_buttons); i++ )
 179       if( !strcmp( menu_buttons[i].name, loc ) )
 180          return i;
 181
 182    assert(0);
 183    return 0;
 184 }
 185
 186 VG_STATIC void menu_btn_reset( int event )
 187 {
 188    reset_player(0,NULL);
 189    world_routes_clear();
 190
 191    cl_menu_go_away = 1;
 192    game_menu.page = 0;
 193 }
 194
 195 VG_STATIC void menu_btn_fuckoff( int event )
 196 {
 197    glfwSetWindowShouldClose( vg.window, 1 );
 198 }
 199
 200 VG_STATIC void menu_btn_quit( int event )
 201 {
 202    game_menu.page = k_menu_page_quit;
 203    game_menu.loc = menu_get_loc( "text_yes" );
 204 }
 205
 206 VG_STATIC void menu_btn_settings( int event )
 207 {
 208    game_menu.page = k_menu_page_settings;
 209    game_menu.loc = menu_get_loc( "fov_slider" );
 210 }
 211
 212 VG_STATIC void menu_btn_skater( int event )
 213 {
 214    game_menu.page = k_menu_page_skater;
 215 }
 216
 217 VG_STATIC void menu_btn_map( int event )
 218 {
 219    game_menu.page = k_menu_page_map;
 220    game_menu.map_count = 0;
 221    game_menu.selected_map = 0;
 222
 223    cf_dir_t dir;
 224    cf_dir_open( &dir, "maps" );
 225
 226    while( dir.has_next )
 227    {
 228       cf_file_t file;
 229       cf_read_file( &dir, &file );
 230
 231       if( file.is_reg )
 232       {
 233          struct menu_map_file *mf = &game_menu.maps_list[ game_menu.map_count ];
 234
 235          vg_strncpy( file.name, mf->name,
 236                                 vg_list_size(game_menu.maps_list[0].name)-1 );
 237
 238          game_menu.map_count ++;
 239          if( game_menu.map_count == vg_list_size(game_menu.maps_list) )
 240             break;
 241       }
 242
 243       cf_dir_next( &dir );
 244    }
 245
 246    cf_dir_close(&dir);
 247 }
 248
 249 VG_STATIC void menu_crap_ui(void)
 250 {
 251    if( cl_menu && (game_menu.page == k_menu_page_map) )
 252    {
 253       ui_rect box;
 254       box[0] = vg.window_x/2 - 150;
 255       box[1] = vg.window_y/2 - 300;
 256       box[2] = 300;
 257       box[3] = 600;
 258
 259       ui_fill_rect( box, 0xa0000000 );
 260
 261       if( game_menu.map_count == 0 )
 262       {
 263          ui_text( (ui_rect){ vg.window_x/2, box[1]+8, 0,0 }, "No maps found", 1,
 264                   k_text_align_center );
 265       }
 266       else
 267       {
 268          ui_rect_pad( box, 4 );
 269          box[3] = 16;
 270
 271          for( int i=0; i<game_menu.map_count; i++ )
 272          {
 273             struct menu_map_file *mf = &game_menu.maps_list[ i ];
 274
 275             ui_fill_rect( box, game_menu.selected_map == i? 0xa0ffffff:
 276                                                             0xa0808080 );
 277             ui_text( (ui_rect){ vg.window_x/2, box[1]+2, 0,0 },
 278                                  mf->name, 1, k_text_align_center );
 279             box[1] += 16+4;
 280          }
 281       }
 282    }
 283 }
 284
 285 VG_STATIC void steam_on_game_overlay( CallbackMsg_t *msg )
 286 {
 287    GameOverlayActivated_t *inf = (GameOverlayActivated_t *)msg->m_pubParam;
 288    vg_info( "Steam game overlay activated; pausing\n" );
 289
 290    if( inf->m_bActive )
 291    {
 292       cl_menu = 1;
 293       game_menu.page = k_menu_page_main;
 294       game_menu.loc = menu_get_loc( "text_skater" );
 295    }
 296 }
 297
 298 VG_STATIC void menu_init(void)
 299 {
 300    vg_create_unnamed_input( &input_menu_h, k_input_type_axis );
 301    vg_create_unnamed_input( &input_menu_v, k_input_type_axis );
 302    vg_create_unnamed_input( &input_menu_back, k_input_type_button );
 303    vg_create_unnamed_input( &input_menu_press, k_input_type_button );
 304    vg_create_unnamed_input( &input_menu_toggle, k_input_type_button );
 305    vg_create_unnamed_input( &input_menu_toggle_kbm, k_input_type_button );
 306
 307    vg_apply_bind_str( &input_menu_h, "", "gp-ls-h" );
 308    vg_apply_bind_str( &input_menu_h, "+", "right" );
 309    vg_apply_bind_str( &input_menu_h, "-", "left" );
 310    vg_apply_bind_str( &input_menu_v, "", "-gp-ls-v" );
 311    vg_apply_bind_str( &input_menu_v, "+", "up" );
 312    vg_apply_bind_str( &input_menu_v, "-", "down" );
 313    vg_apply_bind_str( &input_menu_press, "", "gp-a" );
 314    vg_apply_bind_str( &input_menu_press, "", "\2enter" );
 315    vg_apply_bind_str( &input_menu_back, "", "gp-b" );
 316    vg_apply_bind_str( &input_menu_back, "", "\2escape" );
 317    vg_apply_bind_str( &input_menu_toggle_kbm, "", "\2escape" );
 318    vg_apply_bind_str( &input_menu_toggle, "", "\2gp-menu" );
 319
 320    vg_linear_clear( vg_mem.scratch );
 321
 322    mdl_open( &menu_model, "models/rs_menu.mdl" );
 323    mdl_load_metadata( &menu_model, vg_mem.rtmemory );
 324    mdl_load_mesh_data( &menu_model, vg_mem.scratch );
 325    mdl_invert_uv_coordinates( &menu_model );
 326    mdl_close( &menu_model );
 327
 328    vg_acquire_thread_sync();
 329    {
 330       mdl_unpack_glmesh( &menu_model, &menu_glmesh );
 331       vg_tex2d_init( (vg_tex2d *[]){ &tex_menu }, 1 );
 332    }
 333    vg_release_thread_sync();
 334
 335    for( int i=0; i<vg_list_size(menu_buttons); i++ )
 336    {
 337       struct menu_button *btn = &menu_buttons[i];
 338       btn->pnode = mdl_node_from_name( &menu_model, btn->name );
 339
 340       if( !btn->pnode )
 341          vg_fatal_exit_loop( "Menu programming error" );
 342    }
 343
 344    menu_pnode_fov_max = mdl_node_from_name( &menu_model, "fov_slider_max" );
 345    menu_pnode_fov_min = mdl_node_from_name( &menu_model, "fov_slider_min" );
 346    menu_pnode_fov_slider = mdl_node_from_name( &menu_model, "fov_slider" );
 347
 348    shader_menu_register();
 349
 350 #ifdef SR_NETWORKED
 351    steam_register_callback( k_iGameOverlayActivated, steam_on_game_overlay );
 352 #endif
 353 }
 354
 355 VG_STATIC void menu_run_directional(void)
 356 {
 357    struct menu_button *btn = &menu_buttons[ game_menu.loc ];
 358
 359    if( vg_input_button_down( &input_menu_press ) )
 360    {
 361       if( btn->fn_press )
 362       {
 363          audio_lock();
 364          audio_play_oneshot( &audio_ui[0], 1.0f );
 365          audio_unlock();
 366
 367          btn->fn_press( 1 );
 368          return;
 369       }
 370    }
 371
 372    if( menu_input_cooldown <= 0.0f )
 373    {
 374       v2f dir = {  input_menu_h.axis.value,
 375                   -input_menu_v.axis.value };
 376
 377       if( v2_length2( dir ) > 0.8f*0.8f )
 378       {
 379          const char *link = NULL;
 380
 381          if( fabsf(dir[0]) > fabsf(dir[1]) )
 382          {
 383             if( dir[0] > 0.0f ) link = btn->lr;
 384             else link = btn->ll;
 385          }
 386          else
 387          {
 388             if( dir[1] > 0.0f ) link = btn->ld;
 389             else link = btn->lu;
 390          }
 391
 392          if( link )
 393          {
 394             game_menu.loc = menu_get_loc( link );
 395             menu_input_cooldown = 0.25f;
 396          }
 397       }
 398    }
 399 }
 400
 401 VG_STATIC int menu_page_should_backout(void)
 402 {
 403    return vg_input_button_down( &input_menu_back );
 404 }
 405
 406 VG_STATIC void menu_close(void)
 407 {
 408    cl_menu_go_away = 1;
 409    game_menu.page = 0;
 410    game_menu.loc = menu_get_loc( "text_skater" );
 411 }
 412
 413 VG_STATIC void menu_page_main(void)
 414 {
 415    if( menu_page_should_backout() )
 416    {
 417       menu_close();
 418       return;
 419    }
 420
 421    menu_fov_target = 112.0f;
 422    menu_run_directional();
 423 }
 424
 425 VG_STATIC void menu_page_map(void)
 426 {
 427    if( menu_page_should_backout() )
 428    {
 429       game_menu.page = k_menu_page_main;
 430       game_menu.loc = menu_get_loc( "text_map" );
 431    }
 432
 433    if( game_menu.map_count > 0 )
 434    {
 435       float v = input_menu_v.axis.value;
 436       if( (fabsf(v) > 0.7f) && (menu_input_cooldown <= 0.0f) )
 437       {
 438          audio_lock();
 439          audio_play_oneshot( &audio_rewind[4], 1.0f );
 440          audio_unlock();
 441
 442          if( v < 0.0f )
 443          {
 444             game_menu.selected_map --;
 445
 446             if( game_menu.selected_map < 0 )
 447                game_menu.selected_map = game_menu.map_count-1;
 448
 449             menu_input_cooldown = 0.25f;
 450          }
 451          else
 452          {
 453             game_menu.selected_map ++;
 454
 455             if( game_menu.selected_map >= game_menu.map_count )
 456                game_menu.selected_map = 0;
 457
 458             menu_input_cooldown = 0.25f;
 459          }
 460       }
 461
 462       if( vg_input_button_down( &input_menu_press ) )
 463       {
 464          /* load map */
 465          char temp[256];
 466          strcpy( temp, "maps/" );
 467          strcat( temp, game_menu.maps_list[game_menu.selected_map].name );
 468
 469          world_change_world( 1, (const char *[]){ temp } );
 470          menu_close();
 471       }
 472    }
 473
 474    menu_fov_target = 80.0f;
 475 }
 476
 477 VG_STATIC void menu_page_quit(void)
 478 {
 479    if( menu_page_should_backout() )
 480    {
 481       game_menu.page = k_menu_page_main;
 482       game_menu.loc = menu_get_loc( "text_quit" );
 483    }
 484
 485    menu_fov_target = 90.0f;
 486    menu_run_directional();
 487 }
 488
 489 VG_STATIC void menu_page_skater(void)
 490 {
 491    float h = input_menu_h.axis.value;
 492    menu_fov_target = 97.0f;
 493
 494    if( menu_page_should_backout() )
 495    {
 496       game_menu.page = k_menu_page_main;
 497       game_menu.loc = menu_get_loc( "text_skater" );
 498       return;
 499    }
 500
 501    if( (fabsf(h) > 0.7f) && (menu_input_cooldown <= 0.0f) )
 502    {
 503       audio_lock();
 504       audio_play_oneshot( &audio_rewind[4], 1.0f );
 505       audio_unlock();
 506
 507       if( h < 0.0f )
 508       {
 509          cl_playermdl_id --;
 510          if( cl_playermdl_id < 0 )
 511             cl_playermdl_id = 2;
 512
 513          int li = menu_get_loc( "skater_left" );
 514
 515          menu_buttons[li].fsize = 0.4f;
 516          menu_buttons[li].falpha = 1.0f;
 517
 518          menu_input_cooldown = 0.25f;
 519       }
 520       else
 521       {
 522          cl_playermdl_id ++;
 523          if( cl_playermdl_id > 2 )
 524             cl_playermdl_id = 0;
 525
 526          int ri = menu_get_loc( "skater_left" );
 527
 528          menu_buttons[ri].fsize = 0.4f;
 529          menu_buttons[ri].falpha = 1.0f;
 530
 531          menu_input_cooldown = 0.25f;
 532       }
 533    }
 534 }
 535
 536 VG_STATIC void menu_page_settings(void)
 537 {
 538    float h = input_menu_h.axis.value;
 539    if( fabsf(h) > 0.04f )
 540       g_fov_option += h * vg.frame_delta;
 541    g_fov_option = vg_clampf( g_fov_option, 0.0f, 1.0f );
 542
 543    v3_lerp( menu_pnode_fov_min->co, menu_pnode_fov_max->co, g_fov_option,
 544             menu_pnode_fov_slider->co );
 545
 546    menu_fov_target = vg_lerpf( 97.0f, 135.0f, g_fov_option ) * 0.8f;
 547
 548    if( menu_page_should_backout() )
 549    {
 550       game_menu.page = k_menu_page_main;
 551       game_menu.loc = menu_get_loc( "text_settings" );
 552       return;
 553    }
 554 }
 555
 556 VG_STATIC void menu_update(void)
 557 {
 558    vg_input_update( 1, &input_menu_h );
 559    vg_input_update( 1, &input_menu_v );
 560    vg_input_update( 1, &input_menu_back );
 561    vg_input_update( 1, &input_menu_press );
 562    vg_input_update( 1, &input_menu_toggle );
 563    vg_input_update( 1, &input_menu_toggle_kbm );
 564
 565    int toggle_gp = vg_input_button_down( &input_menu_toggle ),
 566        toggle_kb = vg_input_button_down( &input_menu_toggle_kbm ),
 567        wait_for_a_sec = 0;
 568
 569    if( toggle_gp || toggle_kb )
 570    {
 571       if( cl_menu )
 572       {
 573          if( toggle_gp )
 574          {
 575             menu_close();
 576          }
 577       }
 578       else
 579       {
 580          if( toggle_kb )
 581             wait_for_a_sec = 1;
 582
 583          cl_menu = 1;
 584          game_menu.page = 1;
 585       }
 586    }
 587
 588    if( !wait_for_a_sec && cl_menu )
 589    {
 590       if( game_menu.page == k_menu_page_main )
 591          menu_page_main();
 592       else if( game_menu.page == k_menu_page_skater )
 593          menu_page_skater();
 594       else if( game_menu.page == k_menu_page_quit )
 595          menu_page_quit();
 596       else if( game_menu.page == k_menu_page_settings )
 597          menu_page_settings();
 598       else if( game_menu.page == k_menu_page_map )
 599          menu_page_map();
 600    }
 601
 602    struct menu_button *btn = &menu_buttons[ game_menu.loc ];
 603
 604    v3f pos;
 605    v2f angles;
 606
 607    /* Base */
 608    {
 609       v3f lookdir;
 610       v3f *mtx = player.mdl.sk.final_mtx[player.mdl.id_head];
 611       m3x3_mulv( mtx, (v3f){-1.0f,0.0f,0.0f}, lookdir );
 612
 613       lookdir[1] = 0.0f;
 614       v3_normalize( lookdir );
 615
 616       v3f center_rough;
 617
 618       if( player.is_dead )
 619       {
 620          v3_copy(player.mdl.ragdoll[ player.mdl.id_hip-1 ].rb.co, center_rough);
 621       }
 622       else
 623       {
 624          v3_add( player.camera_pos, player.visual_transform[3], center_rough );
 625          v3_muls( center_rough, 0.5f, center_rough );
 626       }
 627
 628       v3_muladds( center_rough, lookdir, 1.5f, pos );
 629       v3_add( (v3f){ 0.0f,0.8f,0.0f}, pos, pos );
 630
 631       angles[1] = 0.0f;
 632       angles[0] = -atan2f( lookdir[0], lookdir[2] );
 633
 634       /* setup model matrix */
 635       v4f qmenu_mdl;
 636       q_axis_angle( qmenu_mdl, (v3f){0.0f,1.0f,0.0f}, -angles[0] );
 637
 638       q_m3x3( qmenu_mdl, menu_mdl_mtx );
 639       v3_copy( center_rough, menu_mdl_mtx[3] );
 640    }
 641
 642    /* Extra */
 643    {
 644       v3f delta;
 645       v3_sub( btn->pnode->co, (v3f){ 0.0f,1.5f,-1.5f }, delta );
 646       v3_normalize( delta );
 647
 648       float y = atan2f( delta[0], delta[2] ),
 649             p = -sinf(delta[1]),
 650             dt = vg.frame_delta;
 651
 652       menu_extra_angles[0] = vg_lerpf( menu_extra_angles[0], y, dt );
 653       menu_extra_angles[1] = vg_lerpf( menu_extra_angles[1], p, dt );
 654
 655       v2_muladds( angles, menu_extra_angles, 0.8f, angles );
 656       angles[0] = fmodf( angles[0], VG_TAUf );
 657    }
 658
 659    /* Update camera */
 660    {
 661       camera_angles[0] = vg_alerpf( camera_angles[0], angles[0], menu_opacity );
 662       camera_angles[1] = vg_lerpf ( camera_angles[1], angles[1], menu_opacity );
 663       v3_lerp( camera_pos, pos, menu_opacity, camera_pos );
 664       camera_update();
 665    }
 666
 667    float dt = vg.frame_delta * 6.0f;
 668    menu_opacity = vg_lerpf( menu_opacity, cl_menu&&!cl_menu_go_away, dt );
 669
 670    if( menu_opacity <= 0.01f )
 671    {
 672       cl_menu = 0;
 673       cl_menu_go_away = 0;
 674    }
 675
 676    vg.time_rate = 1.0-(double)menu_opacity;
 677
 678    if( cl_menu )
 679    {
 680       menu_input_cooldown -= vg.frame_delta;
 681    }
 682 }
 683
 684 /* https://iquilezles.org/articles/functions/ */
 685 float expSustainedImpulse( float x, float f, float k )
 686 {
 687     float s = fmaxf(x-f,0.0f);
 688     return fminf( x*x/(f*f), 1.0f+(2.0f/f)*s*expf(-k*s));
 689 }
 690
 691 VG_STATIC void menu_render( m4x4f projection )
 692 {
 693    glEnable(GL_BLEND);
 694    glDisable(GL_DEPTH_TEST);
 695    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 696    glBlendEquation(GL_FUNC_ADD);
 697
 698    shader_fscolour_use();
 699    shader_fscolour_uColour( (v4f){ 0.1f, 0.1f, 0.3f, menu_opacity*0.5f } );
 700    render_fsquad();
 701
 702    glEnable( GL_DEPTH_TEST );
 703    glDisable( GL_BLEND );
 704
 705    m4x3f mtx;
 706
 707    shader_menu_use();
 708    shader_menu_uColour( (v4f){ 1.0f,1.0f,1.0f,1.0f} );
 709    shader_menu_uTexMain( 1 );
 710    vg_tex2d_bind( &tex_menu, 1 );
 711
 712    shader_menu_uPv( projection );
 713    mesh_bind( &menu_glmesh );
 714
 715    for( int i=0; i<vg_list_size(menu_buttons); i++ )
 716    {
 717       struct menu_button *btn = &menu_buttons[i];
 718       float talpha = i==game_menu.loc? 1.0f: 0.0f,
 719             tsize0 = btn->fn_visibility( btn->user )? 1.0f: 0.0f,
 720             tsize1 = i==game_menu.loc? 0.07f: 0.0f,
 721             tsize  = tsize0+tsize1;
 722
 723       btn->falpha = vg_lerpf( btn->falpha, talpha, vg.frame_delta * 14.0f );
 724       btn->fsize  = vg_lerpf( btn->fsize,  tsize,  vg.frame_delta * 3.0f  );
 725
 726       /* Colour */
 727       v4f vselected = {0.95f*1.3f,0.45f*1.3f,0.095f*1.3f, 1.0f},
 728           vnormal   = {1.0f,1.0f,1.0f, 1.0f},
 729           vcurrent;
 730
 731       v4_lerp( vnormal, vselected, btn->falpha, vcurrent );
 732       shader_menu_uColour( vcurrent );
 733
 734       /* Create matrix */
 735       m4x3f mtx_size;
 736       mdl_node_transform( btn->pnode, mtx );
 737       m4x3_mul( menu_mdl_mtx, mtx, mtx );
 738       m4x3_identity( mtx_size );
 739       m4x3_scale( mtx_size, expSustainedImpulse( btn->fsize, 0.5f, 8.7f) );
 740       m4x3_mul( mtx, mtx_size, mtx );
 741       shader_menu_uMdl( mtx );
 742
 743       for( int j=0; j<btn->pnode->submesh_count; j++ )
 744       {
 745          mdl_submesh *sm =
 746             &menu_model.submesh_buffer[ btn->pnode->submesh_start+j ];
 747          mdl_draw_submesh( sm );
 748       }
 749    }
 750
 751    /*
 752    for( int i=0; i<menu_model->node_count; i++ )
 753    {
 754       mdl_node *pnode = mdl_node_from_id( menu_model, i );
 755
 756       for( int j=0; j<pnode->submesh_count; j++ )
 757       {
 758          mdl_submesh *sm =
 759             mdl_submesh_from_id( menu_model, pnode->submesh_start+j );
 760
 761          mdl_node_transform( pnode, mtx );
 762          m4x3_mul( menu_mdl_mtx, mtx, mtx );
 763          shader_menu_uMdl( mtx );
 764
 765          mdl_draw_submesh( sm );
 766       }
 767    }
 768    */
 769 }
 770
 771 #endif /* MENU_H */