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