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