world_routes_ui.c

   1 #include "skaterift.h"
   2 #include "world_routes_ui.h"
   3 #include "world_routes.h"
   4
   5 static u32 v4_rgba( v4f colour ){
   6    u32 r = vg_minf(1.0f,colour[0])*255.0f,
   7        g = vg_minf(1.0f,colour[1])*255.0f,
   8        b = vg_minf(1.0f,colour[2])*255.0f,
   9        a = vg_minf(1.0f,colour[3])*255.0f;
  10
  11    return r | (g<<8) | (b<<16) | (a<<24);
  12 }
  13
  14 static void ent_route_imgui( world_instance *world, ent_route *route,
  15                              ui_point inout_cursor ){
  16    if( route->flags & k_ent_route_flag_out_of_zone )
  17       return;
  18
  19    u32 last_version=0;
  20    f64 last_time = 0.0;
  21    ent_checkpoint *last_cp = NULL;
  22
  23    u32 valid_sections=0;
  24
  25    struct time_block{
  26       f32 length, best;
  27       int clean;
  28    }
  29    blocks[ route->checkpoints_count ];
  30
  31    for( u32 i=0; i<route->checkpoints_count; i++ ){
  32       u32 cpid  = i+route->active_checkpoint+1;
  33           cpid %= route->checkpoints_count;
  34           cpid += route->checkpoints_start;
  35
  36       ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, cpid );
  37       ent_gate *rg = mdl_arritm( &world->ent_gate, cp->gate_index );
  38                 rg = mdl_arritm( &world->ent_gate, rg->target );
  39
  40       if( last_version+1 == rg->timing_version ) {
  41          struct time_block *block = &blocks[ valid_sections ++ ];
  42          block->clean  = (rg->flags & k_ent_gate_clean_pass)? 1: 0;
  43          block->length = rg->timing_time - last_time;
  44          block->best = last_cp? last_cp->best_time: 0.0f;
  45       }
  46       else valid_sections = 0;
  47
  48       last_version = rg->timing_version;
  49       last_time = rg->timing_time;
  50       last_cp = cp;
  51    }
  52
  53    if( last_version+1 == world_static.current_run_version ){
  54       struct time_block *block = &blocks[ valid_sections ++ ];
  55       block->clean = localplayer.rewinded_since_last_gate? 0: 1;
  56       block->length = world_static.time - last_time;
  57       block->best = last_cp->best_time;
  58    }
  59    else
  60       valid_sections = 0;
  61
  62    u32 colour = v4_rgba( route->colour ) | 0xff000000;
  63
  64    ui_px x = 0,
  65          h = route->factive * 16.0f,
  66          base = inout_cursor[0];//(f32)vg.window_x*0.5f - route->ui_stopper;
  67
  68    if( route->ui_residual > 0.0f ){
  69       ui_px w = route->ui_residual_block_w,
  70             total = w + 4;
  71
  72       f32 t = vg_smoothstepf(1.0f-route->ui_residual);
  73
  74       x -= (f32)total * t;
  75
  76       ui_rect rect = { base+x, inout_cursor[1], w, h };
  77
  78       v4f fadecolour;
  79       v4_copy( route->colour, fadecolour );
  80       fadecolour[3] *= route->ui_residual;
  81
  82       ui_fill( rect, v4_rgba(fadecolour) );
  83
  84       x += total;
  85    }
  86
  87    int got_first = 0;
  88
  89    for( u32 i=0; i<valid_sections; i ++ ){
  90       struct time_block *block = &blocks[ i ];
  91       ui_px w = 20 + (block->length * 6.0f);
  92       ui_rect rect = { base+x, inout_cursor[1], w, h };
  93       ui_fill( rect, colour );
  94
  95       if( block->clean )
  96          ui_outline( rect, 1, 0xff00ffff, 0 );
  97
  98       if( block->best != 0.0f ){
  99          char buf[32];
 100          vg_str str;
 101          vg_strnull( &str, buf, 32 );
 102
 103          f32 diff = block->length - block->best,
 104              as = fabsf(diff),
 105              s  = floorf( as ),
 106              ds = floorf( vg_fractf( as ) * 10.0f );
 107
 108          if( (block->best != 0.0f) && (fabsf(diff) > 0.001f) ){
 109             if( diff > 0.0f )
 110                vg_strcatch( &str, '+' );
 111             else
 112                vg_strcatch( &str, '-' );
 113
 114             vg_strcati32( &str, s );
 115             vg_strcatch( &str, '.' );
 116             vg_strcati32( &str, ds );
 117
 118             ui_text( rect, buf, 1, k_ui_align_middle_center, 0 );
 119          }
 120       }
 121
 122       x += w + 4;
 123
 124       if( !got_first ){
 125          route->ui_first_block_width = w;
 126          got_first = 1;
 127       }
 128    }
 129
 130    for( u32 i=0; i<route->checkpoints_count-valid_sections; i++ ){
 131       struct time_block *block = &blocks[ i ];
 132
 133       ui_px w = 20;
 134       ui_rect rect = { base+x, inout_cursor[1], w, h };
 135       ui_outline( rect, -1, colour, 0 );
 136       x += w + 4;
 137
 138       if( !got_first ){
 139          route->ui_first_block_width = w;
 140          got_first = 1;
 141       }
 142    }
 143
 144    inout_cursor[1] += h + 4;
 145
 146    vg_slewf( &route->ui_residual, 0.0f, vg.time_frame_delta );
 147    route->ui_stopper = vg_lerpf( route->ui_stopper, (f32)x*0.5f,
 148                                  vg.time_frame_delta );
 149 }
 150
 151 static void world_routes_imgui( world_instance *world ){
 152    ui_point cursor = { 4, 4 };
 153    for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
 154       ent_route_imgui( world, mdl_arritm( &world->ent_route, i ), cursor );
 155    }
 156 }