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