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 #include "shaders/model_menu.h"
   9 #include "audio.h"
  10 #include "input.h"
  11 #include "workshop.h"
  12 #include "respawn.h"
  13
  14 #define MENU_STACK_SIZE 8
  15
  16 struct {
  17    int credits_open;
  18    int disable_open;
  19
  20    u32 page, /* current page index */
  21        page_depth,
  22        controls_page_id;
  23
  24    ent_menuitem *ctr_kbm,
  25                 *ctr_deck,
  26                 *ctr_ps,
  27                 *ctr_steam,
  28                 *ctr_xbox;
  29
  30    enum menu_input_mode{
  31       k_menu_input_mode_keys,
  32       k_menu_input_mode_mouse
  33    }
  34    input_mode;
  35    f32 mouse_track, mouse_dist;  /* used for waking up mouse */
  36    f32 slider_offset;
  37
  38    struct page_stack_frame {
  39       u32 page;
  40       ent_menuitem *loc;
  41       ent_camera *cam;
  42    }
  43    page_stack[ MENU_STACK_SIZE ];
  44
  45    ent_menuitem *loc;
  46    ent_camera   *cam;
  47    camera        view;
  48
  49    mdl_context model;
  50    GLuint texture;
  51    glmesh mesh;
  52
  53    mdl_array_ptr items, markers, cameras;
  54 }
  55 static menu;
  56
  57 /*
  58  * Attaches memory locations to the various items in the menu
  59  */
  60 static void menu_link(void){
  61    /* link data locations */
  62    for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
  63       ent_menuitem *item = mdl_arritm( &menu.items, i );
  64
  65       if( item->type == k_ent_menuitem_type_toggle ||
  66           item->type == k_ent_menuitem_type_slider ){
  67
  68          const char *name;
  69
  70          if( item->type == k_ent_menuitem_type_slider )
  71             name = mdl_pstr( &menu.model, item->slider.pstr_data );
  72          else
  73             name = mdl_pstr( &menu.model, item->checkmark.pstr_data );
  74          vg_var *var = vg_console_match_var( name );
  75
  76          if( var ){
  77             if( ( item->type == k_ent_menuitem_type_slider &&
  78                   var->data_type != k_var_dtype_f32
  79                 ) ||
  80                 ( item->type == k_ent_menuitem_type_toggle &&!
  81                   ( var->data_type == k_var_dtype_i32 ||
  82                     var->data_type == k_var_dtype_u32
  83                   )
  84                )
  85             ){
  86                vg_error( "Cannot hook to data %s(%p), because it is type %d.\n",
  87                            name, var, var->data_type );
  88                item->pvoid = NULL;
  89             }
  90             else{
  91                item->pvoid = var->data;
  92             }
  93          }
  94          else{
  95             vg_error( "No data named %s\n", name );
  96             item->pvoid = NULL;
  97          }
  98       }
  99       else{
 100          item->pvoid = NULL;
 101       }
 102    }
 103
 104    /* link controllers */
 105    menu.ctr_deck = NULL;
 106    menu.ctr_kbm = NULL;
 107    menu.ctr_ps = NULL;
 108    menu.ctr_steam = NULL;
 109    menu.ctr_xbox = NULL;
 110
 111    for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
 112       ent_menuitem *item = mdl_arritm( &menu.items, i );
 113
 114       if( MDL_CONST_PSTREQ( &menu.model, item->visual.pstr_name, "deck" ) )
 115          menu.ctr_deck = item;
 116       if( MDL_CONST_PSTREQ( &menu.model, item->visual.pstr_name, "kbm" ) )
 117          menu.ctr_kbm = item;
 118       if( MDL_CONST_PSTREQ( &menu.model, item->visual.pstr_name, "ps" ) )
 119          menu.ctr_ps = item;
 120       if( MDL_CONST_PSTREQ( &menu.model, item->visual.pstr_name, "steam" ) )
 121          menu.ctr_steam = item;
 122       if( MDL_CONST_PSTREQ( &menu.model, item->visual.pstr_name, "xbox" ) )
 123          menu.ctr_xbox = item;
 124    }
 125 }
 126
 127 static void menu_close(void){
 128    skaterift.activity = k_skaterift_default;
 129    menu.page_depth = 0;
 130    menu.page = 0xffffffff;
 131    srinput.enabled = 0;
 132 }
 133
 134 static void menu_init(void){
 135    void *alloc = vg_mem.rtmemory;
 136
 137    mdl_open( &menu.model, "models/rs_menu.mdl", alloc );
 138    mdl_load_metadata_block( &menu.model, alloc );
 139
 140    vg_linear_clear( vg_mem.scratch );
 141
 142    mdl_load_array( &menu.model, &menu.items,   "ent_menuitem", alloc );
 143    mdl_load_array( &menu.model, &menu.markers, "ent_marker", alloc );
 144    mdl_load_array( &menu.model, &menu.cameras, "ent_camera", alloc );
 145
 146    vg_linear_clear( vg_mem.scratch );
 147
 148    if( !mdl_arrcount( &menu.model.textures ) )
 149       vg_fatal_error( "No texture in menu file" );
 150
 151    mdl_texture *tex0 = mdl_arritm( &menu.model.textures, 0 );
 152    void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
 153    mdl_fread_pack_file( &menu.model, &tex0->file, data );
 154
 155    mdl_async_load_glmesh( &menu.model, &menu.mesh );
 156    vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
 157                             VG_TEX2D_LINEAR|VG_TEX2D_CLAMP,
 158                             &menu.texture );
 159
 160    mdl_close( &menu.model );
 161    shader_model_menu_register();
 162 }
 163
 164 /*
 165  * Drop back a page until we're at the bottom which then we jus quit
 166  */
 167 static void menu_back_page(void){
 168    vg_info( "menu_back_page()\n" );
 169    menu.page_depth --;
 170    if( menu.page_depth == 0 ){
 171       menu_close();
 172    }
 173    else{
 174       menu.page = menu.page_stack[ menu.page_depth ].page;
 175       menu.cam = menu.page_stack[ menu.page_depth ].cam;
 176
 177       if( menu.input_mode == k_menu_input_mode_keys )
 178          menu.loc = menu.page_stack[ menu.page_depth ].loc;
 179       else menu.loc = NULL;
 180    }
 181 }
 182
 183 /*
 184  * Open page to the string identifier
 185  */
 186 static void menu_open_page( const char *name ){
 187    if( menu.page_depth >= MENU_STACK_SIZE )
 188       vg_fatal_error( "Stack overflow\n" );
 189
 190    vg_info( "Try to open %s\n", name );
 191
 192    u32 hash = vg_strdjb2( name );
 193    for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
 194       ent_menuitem *item = mdl_arritm( &menu.items, i );
 195
 196       if( item->type == k_ent_menuitem_type_page ){
 197          if( mdl_pstreq( &menu.model, item->page.pstr_name, name, hash ) ){
 198             u32 new_page = __builtin_ctz( item->groups );
 199
 200             if( new_page == menu.page ){
 201                menu_back_page();
 202             }
 203             else{
 204                menu.page_stack[ menu.page_depth    ].page = menu.page;
 205                menu.page_stack[ menu.page_depth    ].cam = menu.cam;
 206                menu.page_stack[ menu.page_depth ++ ].loc = menu.loc;
 207                menu.page = __builtin_ctz( item->groups );
 208
 209                if( menu.input_mode == k_menu_input_mode_keys ){
 210                   if( item->page.id_entrypoint ){
 211                      u32 id = mdl_entity_id_id( item->page.id_entrypoint );
 212                      menu.loc = mdl_arritm( &menu.items, id );
 213                   }
 214                }
 215
 216                if( item->page.id_viewpoint ){
 217                   u32 id = mdl_entity_id_id( item->page.id_viewpoint );
 218                   menu.cam = mdl_arritm( &menu.cameras, id );
 219                }
 220                vg_info( "menu page: %u (%p,%p)\n",
 221                         menu.page, menu.loc, menu.cam );
 222             }
 223             return;
 224          }
 225       }
 226    }
 227 }
 228
 229 /*
 230  * activate a pressable type
 231  */
 232 static void menu_trigger_item( ent_menuitem *item ){
 233    if     ( item->type == k_ent_menuitem_type_event_button ){
 234       u32 q = item->button.pstr;
 235
 236       if( MDL_CONST_PSTREQ( &menu.model, q, "quit" ) ){
 237          vg.window_should_close = 1;
 238       }
 239
 240       /* DEPRECATED? */
 241       else if( MDL_CONST_PSTREQ( &menu.model, q, "reset_nearest" ) ){
 242          localplayer_cmd_respawn( 0, NULL );
 243          menu_close();
 244       }
 245       /* DEPRECATED? */
 246       else if( MDL_CONST_PSTREQ( &menu.model, q, "reset_home" ) ){
 247          world_set_active_instance( 0 );
 248          localplayer.viewable_world = world_current_instance();
 249          localplayer_cmd_respawn( 1, (const char *[]){"start"} );
 250          menu_close();
 251       }
 252
 253       else if( MDL_CONST_PSTREQ( &menu.model, q, "reset" ) ){
 254          menu_close();
 255          respawn_begin_chooser();
 256       }
 257
 258       else if( MDL_CONST_PSTREQ( &menu.model, q, "credits" ) ){
 259          menu.credits_open = 1;
 260       }
 261       else if( MDL_CONST_PSTREQ( &menu.model, q, "workshop" ) ){
 262          workshop_submit_command(0,NULL);
 263       }
 264    }
 265    else if( item->type == k_ent_menuitem_type_page_button ){
 266       menu_open_page( mdl_pstr( &menu.model, item->button.pstr ) );
 267    }
 268    else if( item->type == k_ent_menuitem_type_toggle ){
 269       if( item->pi32 ){
 270          *item->pi32 = *item->pi32 ^ 0x1;
 271       }
 272    }
 273 }
 274
 275 static f32 menu_slider_snap( f32 value, f32 old, f32 notch ){
 276    f32 const k_epsilon = 0.0125f;
 277
 278    if( fabsf(notch-value) < k_epsilon ){
 279       if( fabsf(notch-old) > k_epsilon ){
 280          audio_lock();
 281          audio_oneshot( &audio_ui[0], 1.0f, 0.0f );
 282          audio_unlock();
 283       }
 284
 285       return notch;
 286    }
 287    else
 288       return value;
 289 }
 290
 291 static void menu_setitem_type( ent_menuitem *item,
 292                                enum ent_menuitem_type type ){
 293    if( !item ) return;
 294    item->type = type;
 295 }
 296
 297 /*
 298  * Run from vg_gui every frame
 299  */
 300 static void menu_update(void){
 301    if( workshop_form.page != k_workshop_form_hidden ){
 302       return;
 303    }
 304
 305    int escape = button_down( k_srbind_mback );
 306    if( menu.credits_open ){
 307       if( escape ){
 308          menu.credits_open = 0;
 309       }
 310       return;
 311    }
 312
 313    if( button_down( k_srbind_mopen ) ){
 314       if( skaterift.activity == k_skaterift_default ){
 315          skaterift.activity = k_skaterift_menu;
 316          menu.page = 0xffffffff;
 317          menu_open_page( "Main Menu" );
 318          return;
 319       }
 320    }
 321
 322    if( skaterift.activity != k_skaterift_menu ) return;
 323    enum menu_input_mode prev_mode = menu.input_mode;
 324
 325    /* get buttons inputs
 326     * -------------------------------------------------------------------*/
 327    int ml = button_down( k_srbind_mleft ),
 328        mr = button_down( k_srbind_mright ),
 329        mu = button_down( k_srbind_mup ),
 330        md = button_down( k_srbind_mdown ),
 331        mh = ml-mr,
 332        mv = mu-md,
 333        enter = button_down( k_srbind_maccept );
 334
 335    if( mh||mv||enter ){
 336       menu.input_mode = k_menu_input_mode_keys;
 337    }
 338
 339    /* get mouse inputs
 340     * --------------------------------------------------------------------*/
 341    menu.mouse_dist += v2_length( vg.mouse_delta ); /* TODO: Move to UI */
 342    menu.mouse_track += vg.time_frame_delta;
 343    if( menu.mouse_track > 0.1f ){
 344       menu.mouse_track = fmodf( menu.mouse_track, 0.1f );
 345       if( menu.mouse_dist > 10.0f ){
 346          menu.input_mode = k_menu_input_mode_mouse;
 347          menu.mouse_dist = 0.0f;
 348       }
 349    }
 350
 351    if( ui_clicking(UI_MOUSE_LEFT) || ui_clicking(UI_MOUSE_RIGHT) ){
 352       menu.input_mode = k_menu_input_mode_mouse;
 353    }
 354
 355    if( menu.input_mode == k_menu_input_mode_mouse ){
 356       /*
 357        * handle mouse input
 358        * ------------------------------------------------------------*/
 359       vg_ui.wants_mouse = 1;
 360
 361       /*
 362        * this raycasting is super cumbersome because all the functions were
 363        * designed for other purposes. we dont care though.
 364        */
 365       m4x4f inverse;
 366       m4x4_inv( menu.view.mtx.p, inverse );
 367       v4f coords;
 368       coords[0] = vg_ui.mouse[0];
 369       coords[1] = vg.window_y - vg_ui.mouse[1];
 370       v2_div( coords, (v2f){ vg.window_x, vg.window_y }, coords );
 371       v2_muls( coords, 2.0f, coords );
 372       v2_add( coords, (v2f){-1.0f,-1.0f}, coords );
 373       coords[2] = 1.0f;
 374       coords[3] = 1.0f;
 375       m4x4_mulv( inverse, coords, coords );
 376       v3f ray;
 377       m3x3_mulv( menu.view.transform, coords, ray );
 378       v3_normalize( ray );
 379
 380       if( menu.loc && (menu.loc->type == k_ent_menuitem_type_slider) &&
 381           ui_clicking(UI_MOUSE_LEFT) && menu.loc->pf32 ){
 382
 383          u32 il = mdl_entity_id_id( menu.loc->slider.id_min ),
 384              ir = mdl_entity_id_id( menu.loc->slider.id_max );
 385          ent_marker *ml = mdl_arritm( &menu.markers, il ),
 386                     *mr = mdl_arritm( &menu.markers, ir );
 387
 388          v3f q2;
 389          v3_muladds( menu.view.pos, ray, 100.0f, q2 );
 390
 391          f32 s,t;
 392          v3f c1, c2;
 393          v3f p1, q1, v0;
 394          v3_sub( mr->transform.co, ml->transform.co, v0 );
 395          v3_muladds( ml->transform.co, v0, -1.0f, p1 );
 396          v3_muladds( mr->transform.co, v0,  1.0f, q1 );
 397          closest_segment_segment( p1, q1, menu.view.pos, q2, &s,&t, c1,c2 );
 398
 399          s-=(1.0f/3.0f);
 400          s/=(1.0f/3.0f);
 401
 402          if( ui_click_down(UI_MOUSE_LEFT) ){
 403             menu.slider_offset = *menu.loc->pf32 - s;
 404          }
 405
 406          f32 newvalue = vg_clampf( s+menu.slider_offset, 0.0f, 1.0f );
 407
 408          newvalue = menu_slider_snap( newvalue, *menu.loc->pf32, 0.00f );
 409          newvalue = menu_slider_snap( newvalue, *menu.loc->pf32, 1.00f );
 410          newvalue = menu_slider_snap( newvalue, *menu.loc->pf32, 0.25f );
 411          newvalue = menu_slider_snap( newvalue, *menu.loc->pf32, 0.50f );
 412          newvalue = menu_slider_snap( newvalue, *menu.loc->pf32, 0.75f );
 413
 414          *menu.loc->pf32 = newvalue;
 415          return;
 416       }
 417
 418       ent_menuitem *hit_item = NULL;
 419
 420       for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
 421          ent_menuitem *item = mdl_arritm( &menu.items, i );
 422
 423          if( item->type == k_ent_menuitem_type_page ) continue;
 424          if( item->type == k_ent_menuitem_type_visual ) continue;
 425          if( !(item->groups & (0x1<<menu.page)) ) continue;
 426
 427          ent_menuitem *ray_item = item;
 428
 429          if( item->type == k_ent_menuitem_type_slider ){
 430             u32 subtarget = mdl_entity_id_id( item->slider.id_handle );
 431             ray_item = mdl_arritm( &menu.items, subtarget );
 432          }
 433
 434          v3f local_ray,
 435              local_co;
 436
 437          m4x3f inverse_mtx;
 438          mdl_transform_m4x3( &ray_item->transform, inverse_mtx );
 439          m4x3_invert_full( inverse_mtx, inverse_mtx );
 440
 441          m4x3_mulv( inverse_mtx, menu.view.transform[3], local_co );
 442          m3x3_mulv( inverse_mtx, ray, local_ray );
 443          v3_normalize( local_ray );
 444
 445          local_ray[0] = 1.0f/local_ray[0];
 446          local_ray[1] = 1.0f/local_ray[1];
 447          local_ray[2] = 1.0f/local_ray[2];
 448
 449          for( u32 j=0; j<ray_item->submesh_count; j++ ){
 450             mdl_submesh *sm = mdl_arritm( &menu.model.submeshs,
 451                                            ray_item->submesh_start + j );
 452             if( ray_aabb1( sm->bbx, local_co, local_ray, 1000.0f ) ){
 453                hit_item = item;
 454                break;
 455             }
 456          }
 457       }
 458
 459       if( hit_item != menu.loc ){
 460          menu.loc = hit_item;
 461       }
 462
 463       if( escape ){
 464          menu_back_page();
 465       }
 466       else if( menu.loc ){
 467          if( ui_click_down( UI_MOUSE_LEFT ) ){
 468             menu_trigger_item( menu.loc );
 469          }
 470       }
 471    }
 472    else if( menu.input_mode == k_menu_input_mode_keys ){
 473       /*
 474        * handle button input
 475        * ------------------------------------------------------------*/
 476       if( (prev_mode != k_menu_input_mode_keys) && !menu.loc ){
 477          for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
 478             ent_menuitem *item = mdl_arritm( &menu.items, i );
 479
 480             if( (item->type != k_ent_menuitem_type_page) &&
 481                 (item->type != k_ent_menuitem_type_visual) &&
 482                 (item->groups & (0x1<<menu.page)) ){
 483                menu.loc = item;
 484             }
 485          }
 486       }
 487
 488       if( !menu.loc ) vg_fatal_error( "No location\n" );
 489
 490       if( menu.loc->type == k_ent_menuitem_type_slider && menu.loc->pf32 ){
 491          f32 move = 0.0f;
 492
 493          if( vg_input.display_input_method == k_input_method_controller ){
 494             move += button_press( k_srbind_mright );
 495             move -= button_press( k_srbind_mleft );
 496          }
 497          else{
 498             move += axis_state( k_sraxis_mbrowse_h );
 499          }
 500
 501          move *= vg.time_frame_delta;
 502          *menu.loc->pf32 = vg_clampf( *menu.loc->pf32 + move, 0.0f, 1.0f );
 503
 504          mh = 0;
 505       }
 506
 507       if( escape ){
 508          menu_back_page();
 509       }
 510       else if( enter ){
 511          menu_trigger_item( menu.loc );
 512       }
 513       else if( mh||mv ){
 514          v3f opt;
 515          v3_zero( opt );
 516          f32 best = 0.707f;
 517          ent_menuitem *nextpos = NULL;
 518
 519          opt[0] += mh;
 520          opt[2] += mv;
 521          mdl_transform_vector( &menu.cam->transform, opt, opt );
 522
 523          for( u32 i=0; i<4; i++ ){
 524             u32 id = menu.loc->id_links[i];
 525             if( !id ) continue;
 526             u32 index = mdl_entity_id_id( id );
 527
 528             ent_menuitem *other = mdl_arritm( &menu.items, index );
 529             v3f delta;
 530             v3_sub( menu.loc->transform.co, other->transform.co, delta );
 531             v3_normalize( delta );
 532
 533             f32 score = v3_dot( delta, opt );
 534             if( score > best ){
 535                best = score;
 536                nextpos = other;
 537             }
 538          }
 539
 540          if( nextpos ){
 541             menu.loc = nextpos;
 542          }
 543       }
 544    }
 545
 546    menu_setitem_type( menu.ctr_deck, k_ent_menuitem_type_disabled );
 547    menu_setitem_type( menu.ctr_ps, k_ent_menuitem_type_disabled );
 548    menu_setitem_type( menu.ctr_kbm, k_ent_menuitem_type_disabled );
 549    menu_setitem_type( menu.ctr_xbox, k_ent_menuitem_type_disabled );
 550    menu_setitem_type( menu.ctr_steam, k_ent_menuitem_type_disabled );
 551
 552    if( vg_input.display_input_method == k_input_method_kbm )
 553       menu_setitem_type( menu.ctr_kbm, k_ent_menuitem_type_visual );
 554    else{
 555       if( vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS3 ||
 556           vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS4 ||
 557           vg_input.display_input_type == SDL_CONTROLLER_TYPE_PS5 ){
 558          menu_setitem_type( menu.ctr_ps, k_ent_menuitem_type_visual );
 559       }
 560       else {
 561          menu_setitem_type( menu.ctr_xbox, k_ent_menuitem_type_visual );
 562       }
 563       /* FIXME: Steam/Deck controller detection? */
 564    }
 565 }
 566
 567 /*
 568  * Run from vg_gui when active
 569  */
 570 VG_STATIC void menu_render(void){
 571    glEnable(GL_BLEND);
 572    glDisable(GL_DEPTH_TEST);
 573    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 574    glBlendEquation(GL_FUNC_ADD);
 575
 576    shader_blitcolour_use();
 577    v4f colour;
 578    ui_hex_to_norm( ui_colour( k_ui_bg+3 ), colour );
 579    colour[3] = 0.5f;
 580
 581    shader_blitcolour_uColour( colour );
 582    render_fsquad();
 583
 584    if( (workshop_form.page != k_workshop_form_hidden) ||
 585        (vg_ui.focused_control_type != k_ui_control_none) ){
 586       return;
 587    }
 588
 589    if( menu.credits_open ){
 590       ui_rect panel = { 0,0, 460, 400 },
 591               screen = { 0,0, vg.window_x,vg.window_y };
 592       ui_rect_center( screen, panel );
 593       ui_fill( panel, ui_colour(k_ui_bg) );
 594       ui_outline( panel, 1, ui_colour(k_ui_fg), 0 );
 595       ui_rect_pad( panel, (ui_px[]){8,8} );
 596
 597       ui_rect title;
 598       ui_split( panel, k_ui_axis_h, 28*2, 0, title, panel );
 599       ui_text( title, "Skate Rift - Credits", 2, k_ui_align_middle_center, 0 );
 600       ui_split( panel, k_ui_axis_h, 28, 0, title, panel );
 601       ui_text( title, "Mt.Zero Software", 1, k_ui_align_middle_center, 0 );
 602
 603       ui_split( panel, k_ui_axis_h, 8, 0, title, panel );
 604       ui_split( panel, k_ui_axis_h, 28, 0, title, panel );
 605       ui_text( title, "A game by Harry Godden", 1,
 606                k_ui_align_middle_center, 0 );
 607
 608       ui_split( panel, k_ui_axis_h, 8, 0, title, panel );
 609       ui_split( panel, k_ui_axis_h, 28*2, 0, title, panel );
 610       ui_text( title, "Free Software", 2, k_ui_align_middle_center, 0 );
 611
 612       ui_split( panel, k_ui_axis_h, 8, 0, title, panel );
 613       ui_text( panel,
 614             "Sam Lantinga       - SDL2 - libsdl.org\n"
 615             "Hunter WB          - Anyascii\n"
 616             "David Herberth     - GLAD\n"
 617             "Dominic Szablewski - QOI - qoiformat.org\n"
 618             "Sean Barrett       - stb_image,stb_vorbis,stb_include\n"
 619             "Khronos Group      - OpenGL\n"
 620             , 1, k_ui_align_left, 0 );
 621       return;
 622    }
 623
 624    glEnable( GL_DEPTH_TEST );
 625    glDisable( GL_BLEND );
 626
 627    f32 rate = vg.time_frame_delta * 12.0f;
 628
 629    if( menu.cam ){
 630       camera target;
 631
 632       target.fov = menu.cam->fov;
 633       v3_copy( menu.cam->transform.co, target.pos );
 634
 635       v3f v0;
 636       mdl_transform_vector( &menu.cam->transform, (v3f){0.0f,-1.0f,0.0f}, v0 );
 637       player_vector_angles( target.angles, v0, 1.0f, 0.0f );
 638
 639       camera_lerp( &menu.view, &target, rate, &menu.view );
 640
 641       menu.view.farz = 150.0f;
 642       menu.view.nearz = 0.01f;
 643
 644       camera_update_transform( &menu.view );
 645       camera_update_view( &menu.view );
 646       camera_update_projection( &menu.view );
 647       camera_finalize( &menu.view );
 648    }
 649    else return;
 650
 651    shader_model_menu_use();
 652    shader_model_menu_uTexMain( 1 );
 653    glActiveTexture( GL_TEXTURE1 );
 654    glBindTexture( GL_TEXTURE_2D, menu.texture );
 655    shader_model_menu_uPv( menu.view.mtx.pv );
 656    shader_model_menu_uPvmPrev( menu.view.mtx_prev.pv );
 657
 658    mesh_bind( &menu.mesh );
 659
 660    v4f white, blue;
 661
 662    ui_hex_to_norm( ui_colour( k_ui_fg ), white );
 663    ui_hex_to_norm( ui_colour( k_ui_orange+k_ui_brighter ), blue );
 664
 665    for( u32 i=0; i<mdl_arrcount(&menu.items); i++ ){
 666       ent_menuitem *item = mdl_arritm( &menu.items, i );
 667
 668       if(   item->type == k_ent_menuitem_type_disabled ) continue;
 669       if(   item->type == k_ent_menuitem_type_page ) continue;
 670       if( !(item->groups & (0x1 << menu.page)) ) continue;
 671
 672       int selected = 0;
 673
 674       if( menu.loc ){
 675          if( menu.loc->type == k_ent_menuitem_type_slider ){
 676             u32 subid = menu.loc->slider.id_handle;
 677             if( item == mdl_arritm( &menu.items, mdl_entity_id_id(subid) ))
 678                selected = 1;
 679          }
 680          else{
 681             if( item == menu.loc )
 682                selected = 1;
 683          }
 684       }
 685
 686       item->factive = vg_lerpf( item->factive, selected, rate );
 687       v4f colour;
 688       v4_lerp( white, blue, item->factive, colour );
 689       shader_model_menu_uColour( colour );
 690
 691       f32 scale = 1.0f+item->factive*0.1f;
 692
 693       m4x3f mmdl;
 694       mdl_transform transform = item->transform;
 695       v3_muls( transform.s, scale, transform.s );
 696       mdl_transform_m4x3( &transform, mmdl );
 697
 698       if( item->type == k_ent_menuitem_type_toggle && item->pi32 ){
 699          u32 subid = mdl_entity_id_id( item->checkmark.id_check );
 700          ent_menuitem *subitem = mdl_arritm( &menu.items, subid );
 701
 702          v3_muladds( item->transform.co, item->checkmark.offset, scale,
 703                      subitem->transform.co );
 704
 705          subitem->fvisible = vg_lerpf( subitem->fvisible, *item->pi32, rate );
 706          v3_fill( subitem->transform.s, subitem->fvisible );
 707       }
 708       else if( item->type == k_ent_menuitem_type_slider && item->pf32 ){
 709          u32 il = mdl_entity_id_id( item->slider.id_min ),
 710              ir = mdl_entity_id_id( item->slider.id_max ),
 711              ih = mdl_entity_id_id( item->slider.id_handle );
 712          ent_marker *ml = mdl_arritm( &menu.markers, il ),
 713                     *mr = mdl_arritm( &menu.markers, ir );
 714          ent_menuitem *handle = mdl_arritm( &menu.items, ih );
 715
 716          v3_lerp( ml->transform.co, mr->transform.co, *item->pf32,
 717                   handle->transform.co );
 718       }
 719
 720       shader_model_menu_uMdl( mmdl );
 721
 722       for( u32 j=0; j<item->submesh_count; j++ ){
 723          u32 index = item->submesh_start + j;
 724          mdl_draw_submesh( mdl_arritm( &menu.model.submeshs, index ));
 725       }
 726    }
 727 }
 728
 729 #endif /* MENU_H */