skaterift.c

   1 /*
   2  * =============================================================================
   3  *
   4  * Copyright  .        . .       -----, ,----- ,---.   .---.
   5  * 2021-2023  |\      /| |           /  |      |    | |    /|
   6  *            | \    / | +--        /   +----- +---'  |   / |
   7  *            |  \  /  | |         /    |      |   \  |  /  |
   8  *            |   \/   | |        /     |      |    \ | /   |
   9  *            '        ' '--' [] '----- '----- '     ' '---'  SOFTWARE
  10  *
  11  * =============================================================================
  12  */
  13
  14 #define SR_NETWORKED
  15 #include "common.h"
  16 #include "conf.h"
  17 #include "steam.h"
  18 #include "render.h"
  19 #include "audio.h"
  20 #include "world.h"
  21
  22
  23
  24 #include "player.h"
  25 VG_STATIC player_instance localplayer;
  26 VG_STATIC struct player_avatar localplayer_avatar;
  27 VG_STATIC glmesh localplayer_meshes[3];
  28 vg_tex2d localplayer_texture = { .path = "textures/ch_gradient.qoi" };
  29
  30
  31
  32
  33
  34
  35 #include "network.h"
  36
  37 #if 0
  38 #include "menu.h"
  39 #endif
  40 #include "vehicle.h"
  41
  42 static int cl_ui      = 1,
  43            cl_view_id = 0,
  44            cl_light_edit = 0;
  45
  46 int main( int argc, char *argv[] )
  47 {
  48    vg_mem.use_libc_malloc = 0;
  49    vg_set_mem_quota( 160*1024*1024 );
  50    vg_enter( argc, argv, "Voyager Game Engine" );
  51
  52    return 0;
  53 }
  54
  55 VG_STATIC void highscores_save_at_exit(void)
  56 {
  57    highscores_serialize_all();
  58 }
  59
  60 VG_STATIC void vg_launch_opt(void)
  61 {
  62
  63 }
  64
  65 VG_STATIC int __kill( int argc, const char *argv[] )
  66 {
  67 #if 0
  68    player_use_device( &localplayer, &player_device_dead, &localplayer_dead );
  69 #endif
  70    return 0;
  71 }
  72
  73 VG_STATIC int __respawn( int argc, const char *argv[] )
  74 {
  75    struct respawn_point *rp = NULL, *r;
  76
  77    world_instance *world = get_active_world();
  78
  79    if( argc == 1 )
  80    {
  81       for( int i=0; i<world->spawn_count; i++ )
  82       {
  83          r = &world->spawns[i];
  84          if( !strcmp( r->name, argv[0] ) )
  85          {
  86             rp = r;
  87             break;
  88          }
  89       }
  90
  91       if( !rp )
  92          vg_warn( "No spawn named '%s'\n", argv[0] );
  93    }
  94
  95    if( !rp )
  96    {
  97       float min_dist = INFINITY;
  98
  99       for( int i=0; i<world->spawn_count; i++ )
 100       {
 101          r = &world->spawns[i];
 102          float d = v3_dist2( r->co, localplayer.rb.co );
 103
 104          vg_info( "Dist %s : %f\n", r->name, d );
 105          if( d < min_dist )
 106          {
 107             min_dist = d;
 108             rp = r;
 109          }
 110       }
 111    }
 112
 113    if( !rp )
 114    {
 115       vg_error( "No spawn found\n" );
 116
 117       if( !world->spawn_count )
 118          return 0;
 119
 120       rp = &world->spawns[0];
 121    }
 122
 123    player__spawn( &localplayer, rp );
 124    return 1;
 125 }
 126
 127 VG_STATIC void vg_preload(void)
 128 {
 129    g_conf_init();
 130
 131    common_var_temp();
 132
 133    vg_var_push( (struct vg_var){
 134       .name = "cl_ui",
 135       .data = &cl_ui,
 136       .data_type = k_var_dtype_i32,
 137       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 138       .persistent = 0
 139    });
 140
 141    vg_var_push( (struct vg_var){
 142       .name = "cl_view_id",
 143       .data = &cl_view_id,
 144       .data_type = k_var_dtype_i32,
 145       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 146       .persistent = 0
 147    });
 148
 149    vg_var_push( (struct vg_var){
 150       .name = "ledit",
 151       .data = &cl_light_edit,
 152       .data_type = k_var_dtype_i32,
 153       .opt_i32 = { .min=0, .max=1, .clamp=1 },
 154       .persistent = 0
 155    });
 156
 157    vg_function_push( (struct vg_cmd) {
 158       .name = "respawn",
 159       .function = __respawn,
 160       //.poll_suggest = reset_player_poll
 161    });
 162
 163    vg_function_push( (struct vg_cmd) {
 164       .name = "ded",
 165       .function = __kill,
 166       //.poll_suggest = reset_player_poll
 167    });
 168
 169 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
 170 vg_info(" 2021-2022  |\\      /| |           /  |      |    | |    /| \n" );
 171 vg_info("            | \\    / | +--        /   +----- +---'  |   / | \n" );
 172 vg_info("            |  \\  /  | |         /    |      |   \\  |  /  | \n" );
 173 vg_info("            |   \\/   | |        /     |      |    \\ | /   | \n" );
 174 vg_info("            '        ' '--' [] '----- '----- '     ' '---'  "
 175         "SOFTWARE\n" );
 176
 177    highscores_init( 2000, 50 );
 178    if( !highscores_read() )
 179       highscores_create_db();
 180
 181    vg_loader_step( NULL, highscores_save_at_exit );
 182
 183    steam_init();
 184    vg_loader_step( NULL, steam_end );
 185    vg_loader_step( network_init, network_end );
 186 }
 187
 188 VG_STATIC void load_playermodels(void)
 189 {
 190    vg_linear_clear( vg_mem.scratch );
 191
 192    /*
 193     * load in other player models. This may need to be more sophisticated in
 194     * the futre if we have more of these guys
 195     */
 196    mdl_context ctx_default,
 197                ctx_outlaw,
 198                ctx_jordan;
 199
 200    mdl_open( &ctx_default, "models/ch_new.mdl" );
 201    mdl_load_metadata( &ctx_default, vg_mem.scratch );
 202    mdl_load_mesh_data( &ctx_default, vg_mem.scratch );
 203    mdl_close( &ctx_default );
 204
 205    mdl_open( &ctx_outlaw, "models/ch_outlaw.mdl" );
 206    mdl_load_metadata( &ctx_outlaw, vg_mem.scratch );
 207    mdl_load_mesh_data( &ctx_outlaw, vg_mem.scratch );
 208    mdl_close( &ctx_outlaw );
 209
 210    mdl_open( &ctx_jordan, "models/ch_jordan.mdl" );
 211    mdl_load_metadata( &ctx_jordan, vg_mem.scratch );
 212    mdl_load_mesh_data( &ctx_jordan, vg_mem.scratch );
 213    mdl_close( &ctx_jordan );
 214
 215    vg_acquire_thread_sync();
 216    {
 217       mdl_unpack_glmesh( &ctx_default, &localplayer_meshes[0] );
 218       mdl_unpack_glmesh( &ctx_outlaw,  &localplayer_meshes[1] );
 219       mdl_unpack_glmesh( &ctx_jordan,  &localplayer_meshes[2] );
 220    }
 221    vg_release_thread_sync();
 222
 223    /* FIXME: hack */
 224    shader_model_character_view_register();
 225    vg_acquire_thread_sync();
 226    {
 227       vg_tex2d_init( (vg_tex2d *[]){ &localplayer_texture }, 1 );
 228    }
 229    vg_release_thread_sync();
 230 }
 231
 232 VG_STATIC void vg_load(void)
 233 {
 234    vg_loader_step( render_init, NULL );
 235    //vg_loader_step( menu_init, NULL );
 236    vg_loader_step( world_init, NULL );
 237    //vg_loader_step( player_init, NULL );
 238    //vg_loader_step( vehicle_init, NULL );
 239    //
 240    //vg_loader_step( player_model_init, NULL );
 241
 242    /* ----------------- */
 243    vg_loader_step( load_playermodels, NULL );
 244
 245    /* player setup */
 246    player__create( &localplayer );
 247    player_avatar_load( &localplayer_avatar, "models/ch_new.mdl" );
 248    player__use_avatar( &localplayer, &localplayer_avatar );
 249    player__use_mesh( &localplayer, &localplayer_meshes[0] );
 250    player__use_texture( &localplayer, &localplayer_texture );
 251    player__bind( &localplayer );
 252
 253    /* --------------------- */
 254
 255    vg_bake_shaders();
 256    vg_loader_step( audio_init, audio_free );
 257    world_audio_init();
 258
 259    /* 'systems' are completely loaded now */
 260
 261    /* load home world */
 262    world_load( &world_global.worlds[0], "maps/mp_home.mdl" );
 263
 264 #if 0
 265    world_load( &world_global.worlds[1], "maps/mp_gridmap.mdl" );
 266    world_load( &world_global.worlds[2], "maps/mp_mtzero.mdl" );
 267    world_link_nonlocal_gates( 0, 1 );
 268    world_link_nonlocal_gates( 0, 2 );
 269 #endif
 270
 271    vg_console_load_autos();
 272 }
 273
 274 VG_STATIC void vg_start(void)
 275 {
 276    __respawn( 1, (const char *[]){ "start" } );
 277 }
 278
 279 VG_STATIC void draw_origin_axis(void)
 280 {
 281    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 1.0f, 0.0f, 0.0f }, 0xffff0000 );
 282    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 1.0f, 0.0f }, 0xff00ff00 );
 283    vg_line( (v3f){ 0.0f, 0.0f, 0.0f }, (v3f){ 0.0f, 0.0f, 1.0f }, 0xff0000ff );
 284 }
 285
 286 VG_STATIC void vg_update(void)
 287 {
 288    steam_update();
 289
 290    if( vg.is_loaded )
 291    {
 292       draw_origin_axis();
 293       network_update();
 294
 295 #if 0
 296       if( !gzoomer.inside )
 297          player_update_pre();
 298 #endif
 299
 300       player__pre_update( &localplayer );
 301       world_update( get_active_world(), localplayer.rb.co );
 302
 303       audio_update();
 304    }
 305 }
 306
 307 VG_STATIC void vg_update_fixed(void)
 308 {
 309    if( vg.is_loaded )
 310    {
 311 #if 0
 312       if( !gzoomer.inside )
 313          player_update_fixed();
 314
 315       vehicle_update_fixed();
 316 #endif
 317
 318       player__update( &localplayer );
 319    }
 320 }
 321
 322 VG_STATIC void vg_update_post(void)
 323 {
 324    if( vg.is_loaded )
 325    {
 326 #if 0
 327       if( gzoomer.inside )
 328       {
 329          vehicle_camera();
 330       }
 331       else
 332       {
 333          player_update_post();
 334       }
 335 #endif
 336
 337       player__post_update( &localplayer );
 338
 339
 340       float inr3 = 0.57735027,
 341             inr2 = 0.70710678118;
 342
 343       v3f sample_directions[] = {
 344          { -1.0f,  0.0f,  0.0f },
 345          {  1.0f,  0.0f,  0.0f },
 346          {  0.0f,  0.0f,  1.0f },
 347          {  0.0f,  0.0f, -1.0f },
 348          {  0.0f,  1.0f,  0.0f },
 349          {  0.0f, -1.0f,  0.0f },
 350          { -inr3,  inr3,  inr3 },
 351          {  inr3,  inr3,  inr3 },
 352          { -inr3,  inr3, -inr3 },
 353          {  inr3,  inr3, -inr3 },
 354          { -inr2,  0.0f,  inr2 },
 355          {  inr2,  0.0f,  inr2 },
 356          { -inr2,  0.0f, -inr2 },
 357          {  inr2,  0.0f, -inr2 },
 358       };
 359
 360       static int si = 0;
 361       static float distances[16];
 362
 363       ray_hit ray;
 364       ray.dist = 5.0f;
 365
 366       v3f rc, rd, ro;
 367       v3_copy( sample_directions[ si ], rd );
 368       v3_add( localplayer.rb.co, (v3f){0.0f,1.5f,0.0f}, ro );
 369       v3_copy( ro, rc );
 370
 371       float dist = 200.0f;
 372
 373       for( int i=0; i<10; i++ )
 374       {
 375          if( ray_world( get_active_world(), rc, rd, &ray ) )
 376          {
 377             dist = (float)i*5.0f + ray.dist;
 378             break;
 379          }
 380          else
 381          {
 382             v3_muladds( rc, rd, ray.dist, rc );
 383          }
 384       }
 385
 386       distances[si] = dist;
 387
 388
 389       for( int i=0; i<14; i++ )
 390       {
 391          if( distances[i] != 200.0f )
 392          {
 393             u32 colours[] = { VG__RED, VG__BLUE, VG__GREEN,
 394                               VG__CYAN, VG__YELOW, VG__PINK,
 395                               VG__WHITE };
 396
 397             u32 colour = colours[i%7];
 398
 399             v3f p1;
 400             v3_muladds( ro, sample_directions[i], distances[i], p1 );
 401             vg_line( ro, p1, colour );
 402             vg_line_pt3( p1, 0.1f, colour );
 403          }
 404       }
 405
 406       si ++;
 407       if( si >= 14 )
 408          si = 0;
 409
 410
 411       /* FIXME: TEMP */
 412       audio_lock();
 413       vg_dsp.echo_distances[si] = dist;
 414
 415       v3f ears = { 1.0f,0.0f,0.0f };
 416       m3x3_mulv( main_camera.transform, ears, ears );
 417       v3_copy( ears, vg_audio.listener_ears );
 418       v3_copy( main_camera.transform[3], vg_audio.listener_pos );
 419       v3_copy( localplayer.rb.v, vg_audio.listener_velocity );
 420       audio_unlock();
 421
 422 #if 0
 423       menu_update();
 424       vehicle_update_post();
 425 #endif
 426    }
 427 }
 428
 429 VG_STATIC void vg_framebuffer_resize( int w, int h )
 430 {
 431    render_fb_resize();
 432 }
 433
 434 VG_STATIC void present_view_with_post_processing(void)
 435 {
 436    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 437
 438    glEnable(GL_BLEND);
 439    glDisable(GL_DEPTH_TEST);
 440    glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
 441    glBlendEquation(GL_FUNC_ADD);
 442
 443    if( cl_blur )
 444    {
 445       shader_blitblur_use();
 446       shader_blitblur_uTexMain( 0 );
 447       shader_blitblur_uTexMotion( 1 );
 448       shader_blitblur_uBlurStrength(cl_blur_strength / (vg.frame_delta*60.0f));
 449
 450       v2f menu_blurring;
 451       //v2_muls( (v2f){ 0.04f, 0.001f }, menu_opacity, menu_blurring );
 452       v2_muls( (v2f){ 0.04f, 0.001f }, 0.0f, menu_blurring );
 453       shader_blitblur_uOverrideDir( menu_blurring );
 454
 455       if( cl_view_id == 0 )
 456          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 457       else if( cl_view_id == 1 )
 458          render_fb_bind_texture( gpipeline.fb_main, 1, 0 );
 459       else
 460          render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 461
 462       render_fb_bind_texture( gpipeline.fb_main, 1, 1 );
 463    }
 464    else
 465    {
 466       shader_blit_use();
 467       shader_blit_uTexMain( 0 );
 468       render_fb_bind_texture( gpipeline.fb_main, 0, 0 );
 469    }
 470
 471    render_fsquad();
 472 }
 473
 474 VG_STATIC void render_player_transparent(void)
 475 {
 476    static camera small_cam;      /* DOES NOT NEED TO BE STATIC BUT MINGW
 477                                     SAIS OTHERWISE */
 478
 479    m4x3_copy( main_camera.transform, small_cam.transform );
 480
 481    small_cam.fov = main_camera.fov;
 482    small_cam.nearz = 0.05f;
 483    small_cam.farz  = 60.0f;
 484
 485    camera_update_view( &small_cam );
 486    camera_update_projection( &small_cam );
 487    camera_finalize( &small_cam );
 488
 489    /* Draw player to window buffer and blend background ontop */
 490    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 491    player__render( &small_cam, &localplayer );
 492 }
 493
 494 VG_STATIC void render_scene(void)
 495 {
 496    render_fb_bind( gpipeline.fb_main );
 497    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
 498    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
 499
 500    /* Draw world */
 501    glEnable( GL_DEPTH_TEST );
 502
 503    world_instance *view_world = localplayer.viewable_world;
 504    render_world( view_world, &main_camera );
 505
 506    int player_transparent = 1,
 507        player_draw        = 1;
 508
 509 #if 0
 510    if( (localplayer.subsystem == k_player_subsystem_dead) ||
 511        (localplayer.camera_mode == k_cam_thirdperson) )
 512       player_transparent = 0;
 513 #endif
 514
 515    if( !player_transparent && player_draw )
 516       player__render( &main_camera, &localplayer );
 517
 518
 519    render_water_texture( view_world, &main_camera );
 520    render_fb_bind( gpipeline.fb_main );
 521    render_water_surface( view_world, &main_camera );
 522    render_world_gates( view_world, &main_camera );
 523
 524    if( player_transparent && player_draw )
 525       render_player_transparent();
 526 }
 527
 528 VG_STATIC void render_menu(void)
 529 {
 530    glClear( GL_DEPTH_BUFFER_BIT );
 531 #if 0
 532    menu_render( &main_camera );
 533 #endif
 534 }
 535
 536 VG_STATIC void render_main_game(void)
 537 {
 538 #if 0
 539    static float fov = 60.0f;
 540    float fov_target = vg_lerpf( 90.0f, 110.0f, cl_fov );
 541
 542    if( player.controller == k_player_controller_skate )
 543       fov_target = vg_lerpf( 97.0f, 135.0f, cl_fov );
 544
 545    if( cl_menu )
 546       fov_target = menu_fov_target;
 547    fov = vg_lerpf( fov, fov_target, vg.frame_delta * 2.0f );
 548    fov = freecam? 60.0f: fov;
 549
 550    main_camera.fov   = fov;
 551 #endif
 552
 553    /* copy camera from player.
 554     * TODO: blend with camera from menu */
 555
 556    /* FIXME: TEMP!! */
 557    player__pre_render( &localplayer );
 558
 559    v3_copy( localplayer.cam.pos, main_camera.pos );
 560    v3_copy( localplayer.cam.angles, main_camera.angles );
 561    main_camera.fov = localplayer.cam.fov;
 562    main_camera.nearz = 0.1f;
 563    main_camera.farz  = 2100.0f;
 564
 565    camera_update_transform( &main_camera );
 566
 567    if( localplayer.gate_waiting )
 568    {
 569       m3x3_mul( localplayer.basis_gate, main_camera.transform,
 570                 main_camera.transform );
 571    }
 572    else
 573    {
 574       m3x3_mul( localplayer.basis, main_camera.transform,
 575                 main_camera.transform );
 576    }
 577
 578    camera_update_view( &main_camera );
 579    camera_update_projection( &main_camera );
 580    camera_finalize( &main_camera );
 581
 582    /* ========== Begin Frame ========== */
 583
 584    render_scene();
 585    present_view_with_post_processing();
 586
 587 #if 0
 588    if( cl_menu )
 589    {
 590       render_menu();
 591       render_player_transparent();
 592    }
 593 #endif
 594
 595    /* =========== End Frame =========== */
 596 }
 597
 598 VG_STATIC void vg_render(void)
 599 {
 600    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
 601
 602    glViewport( 0,0, vg.window_x, vg.window_y );
 603    glDisable( GL_DEPTH_TEST );
 604
 605    glClearColor( 1.0f, 0.0f, 0.0f, 0.0f );
 606    glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );
 607
 608    render_main_game();
 609
 610    m4x4_copy( main_camera.mtx.pv, vg.pv );
 611
 612    /* Other shite */
 613    glDisable(GL_BLEND);
 614    glDisable( GL_DEPTH_TEST );
 615    vg_lines_drawall();
 616    glViewport( 0,0, vg.window_x, vg.window_y );
 617 }
 618
 619 VG_STATIC void run_light_widget( struct light_widget *lw );
 620 VG_STATIC void vg_ui(void)
 621 {
 622    player__im_gui( &localplayer );
 623    world_instance *world = get_active_world();
 624
 625 #if 0
 626    menu_crap_ui();
 627 #endif
 628
 629 #if 0
 630    if( cl_light_edit )
 631    {
 632       vg_uictx.cursor[0] = 10;
 633       vg_uictx.cursor[1] = 10;
 634       vg_uictx.cursor[2] = 200;
 635       vg_uictx.cursor[3] = 20;
 636
 637       struct ub_world_lighting *wl = &gpipeline.ub_world_lighting;
 638       struct ui_slider_vector
 639          s5 = { .min=0.0f, .max=2.0f, .len=3, .data=wl->g_ambient_colour };
 640
 641       struct ui_slider
 642          s8 = { .min=0.0f, .max=2.0f, .data = &gpipeline.shadow_spread },
 643          s9 = { .min=0.0f, .max=25.0f, .data = &gpipeline.shadow_length };
 644
 645       for( int i=0; i<3; i++ )
 646          run_light_widget( &gpipeline.widgets[i] );
 647
 648       ui_text( vg_uictx.cursor, "Ambient", 1, 0 );
 649       vg_uictx.cursor[1] += 16;
 650       ui_slider_vector( &s5 );
 651
 652       ui_text( vg_uictx.cursor, "Shadows", 1, 0 );
 653       vg_uictx.cursor[1] += 16;
 654       ui_slider( &s8 );
 655       ui_slider( &s9 );
 656
 657       ui_text( vg_uictx.cursor, "Misc", 1, 0 );
 658       vg_uictx.cursor[1] += 16;
 659       struct ui_checkbox c1 = {.data = &wl->g_light_preview};
 660       ui_checkbox( &c1 );
 661
 662       render_update_lighting_ub();
 663    }
 664 #endif
 665
 666    //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 667    if( cl_ui )
 668    {
 669       render_world_routes_ui( world );
 670    }
 671    //glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 672
 673    audio_debug_soundscapes();
 674    render_view_framebuffer_ui();
 675
 676 #if 0
 677    player_physics_gui();
 678 #endif
 679 }
 680
 681 VG_STATIC void run_light_widget( struct light_widget *lw )
 682 {
 683    struct ui_checkbox c1 = { .data=&lw->enabled };
 684
 685    ui_checkbox( &c1 );
 686
 687    if( lw->enabled )
 688    {
 689       struct ui_slider_vector
 690          colour = { .min=0.0f, .max=2.0f, .len=3, .data=lw->colour },
 691          dir    = { .min=-VG_PIf, .max=VG_PIf, .len=2, .data=lw->dir };
 692
 693       ui_slider_vector( &colour );
 694       vg_uictx.cursor[1] += 4;
 695       ui_slider_vector( &dir );
 696    }
 697 }
 698
 699 VG_STATIC void run_debug_info(void)
 700 {
 701 #if 0
 702    char buf[40];
 703
 704    snprintf( buf, 40, "%.2fm/s", v3_length( player.rb.v ) );
 705    ui_text( (ui_px [2]){ 0, 0 }, buf, 1, k_text_align_left );
 706
 707    snprintf( buf, 40, "%.2f %.2f %.2f m/s",
 708          player.phys.a[0], player.phys.a[1], player.phys.a[2] );
 709    ui_text( (ui_px [2]){ 0, 20 }, buf, 1, k_text_align_left );
 710
 711    snprintf( buf, 40, "pos %.2f %.2f %.2f",
 712          player.phys.rb.co[0], player.phys.rb.co[1], player.phys.rb.co[2] );
 713    ui_text( (ui_px [2]){ 0, 40 }, buf, 1, k_text_align_left );
 714
 715    if( vg_input.controller_handle )
 716    {
 717       for( int i=0; i<vg_list_size(vg_input.controller_axises); i++ )
 718       {
 719          snprintf( buf, 40, "%.2f", vg_input.controller_axises[i] );
 720          ui_text( (ui_px [2]){ 0, (i+3)*20 }, buf, 1, k_text_align_left );
 721       }
 722    }
 723    else
 724    {
 725       ui_text( (ui_px [2]){ 0, 60 },
 726             "Gamepad not ready", 1, k_text_align_left );
 727    }
 728 #endif
 729 }