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