#define ROUTES_C
#include <time.h>
+#include "entity.h"
#include "world_routes.h"
#include "world_gate.h"
#include "world_load.h"
#include "highscores.h"
+#include "network.h"
#include "font.h"
-#include "pointcloud.h"
#include "gui.h"
+#include "steam.h"
+#include "network_msg.h"
+#include "network_common.h"
#include "shaders/scene_route.h"
#include "shaders/routeui.h"
+#include "ent_region.h"
-
-VG_STATIC
-void world_routes_local_set_record( world_instance *world, ent_route *route,
- double lap_time )
-{
- vg_success( " NEW LAP TIME: %f\n", lap_time );
-
- if( route->official_track_id != 0xffffffff ){
- double time_centiseconds = lap_time * 100.0;
- if( time_centiseconds > (float)0xfffe ) /* skill issue */
- return;
-
- highscore_record temp;
- temp.trackid = route->official_track_id;
- temp.datetime = time(NULL);
- temp.playerid = 0;
- temp.points = 0;
- temp.time = time_centiseconds;
-
-#if 0
- highscores_push_record( &temp );
-#endif
-
- struct track_info *ti = &track_infos[ route->official_track_id ];
- ti->push = 1;
-
- if( ti->achievement_id ){
-#if 0
- steam_set_achievement( ti->achievement_id );
- steam_store_achievements();
-#endif
- }
- }
- else{
- vg_warn( "There is no associated track for this record...\n" );
- }
-}
-
-
-VG_STATIC void world_routes_clear( world_instance *world )
+static void world_routes_clear( world_instance *world )
{
for( u32 i=0; i<mdl_arrcount( &world->ent_route ); i++ ){
ent_route *route = mdl_arritm( &world->ent_route, i );
world_static.last_use = 0.0;
}
-VG_STATIC void world_routes_time_lap( world_instance *world, ent_route *route )
-{
+static void world_routes_time_lap( world_instance *world, ent_route *route ){
vg_info( "------- time lap %s -------\n",
mdl_pstr(&world->meta,route->pstr_name) );
double start_time = 0.0;
u32 last_version=0;
+ f64 last_time = 0.0;
+ ent_checkpoint *last_cp = NULL;
- u32 valid_count=0;
+ u32 valid_sections=0;
+ int clean = !localplayer.rewinded_since_last_gate;
for( u32 i=0; i<route->checkpoints_count; i++ ){
u32 cpid = (i+route->active_checkpoint) % route->checkpoints_count;
if( i == 0 )
start_time = rg->timing_time;
else{
- if( last_version+1 == rg->timing_version ) valid_count ++;
- else valid_count = 0;
+ if( last_version+1 == rg->timing_version ) valid_sections ++;
+ else valid_sections = 0;
}
+ vg_info( "%u %f [%s]\n", rg->timing_version, rg->timing_time,
+ i? ((rg->flags & k_ent_gate_clean_pass)? "CLEAN": " "):
+ " N/A ");
+
+ if( !(rg->flags & k_ent_gate_clean_pass) )
+ clean = 0;
+
last_version = rg->timing_version;
- vg_info( "%u %f\n", rg->timing_version, rg->timing_time );
+ last_time = rg->timing_time;
+ last_cp = cp;
}
if( world_static.current_run_version == last_version+1 ){
- valid_count ++;
+ valid_sections ++;
if( route->checkpoints_count == 1 ){
route->timing_base = world_static.time;
}
+
+ f32 section = world_static.time - last_time;
+ if( (section < last_cp->best_time) || (last_cp->best_time == 0.0f) ){
+ last_cp->best_time = section;
+ }
}
- else valid_count = 0;
+ else valid_sections = 0;
+
+ vg_info( "%u %f [%s]\n",
+ world_static.current_run_version, world_static.time,
+ !localplayer.rewinded_since_last_gate? "CLEAN": " " );
+
+ if( valid_sections==route->checkpoints_count ){
+ f64 lap_time = world_static.time - start_time;
+
+ if( (route->best_laptime == 0.0) || (lap_time < route->best_laptime) ){
+ route->best_laptime = lap_time;
+ }
- vg_info( "%u %f\n", world_static.current_run_version, world_static.time );
+ route->flags |= k_ent_route_flag_achieve_silver;
+ if( clean ) route->flags |= k_ent_route_flag_achieve_gold;
+ ent_region_re_eval( world );
- if( valid_count==route->checkpoints_count ){
- double lap_time = world_static.time - start_time;
- world_routes_local_set_record( world, route, lap_time );
+ /* for steam achievements. */
+ if( route->anon.official_track_id != 0xffffffff ){
+ struct track_info *ti = &track_infos[ route->anon.official_track_id ];
+ if( ti->achievement_id ){
+ steam_set_achievement( ti->achievement_id );
+ steam_store_achievements();
+ }
+ }
+
+ addon_alias *alias =
+ &world_static.instance_addons[ world_static.active_instance ]->alias;
+
+ char mod_uid[ ADDON_UID_MAX ];
+ addon_alias_uid( alias, mod_uid );
+ network_publish_laptime( mod_uid,
+ mdl_pstr( &world->meta, route->pstr_name ),
+ lap_time );
}
- route->valid_checkpoints = valid_count+1;
+ route->valid_checkpoints = valid_sections+1;
- vg_info( "valid: %u\n", valid_count );
+ vg_info( "valid sections: %u\n", valid_sections );
vg_info( "----------------------------\n" );
+
+ route->ui_residual = 1.0f;
+ route->ui_residual_block_w = route->ui_first_block_width;
}
/*
* When going through a gate this is called for bookkeeping purposes
*/
-VG_STATIC void world_routes_activate_entry_gate( world_instance *world,
+static void world_routes_activate_entry_gate( world_instance *world,
ent_gate *rg )
{
world_static.last_use = world_static.time;
-
- /* disable all routes and leave the world */
- if( rg->type == k_gate_type_nonlocel ){
- for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
- ent_route *route = mdl_arritm( &world->ent_route, i );
- route->active_checkpoint = 0xffff;
- }
- return;
- }
-
ent_gate *dest = mdl_arritm( &world->ent_gate, rg->target );
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
dest->timing_version = world_static.current_run_version;
dest->timing_time = world_static.time;
+ if( localplayer.rewinded_since_last_gate ){
+ localplayer.rewinded_since_last_gate = 0;
+ dest->flags &= ~k_ent_gate_clean_pass;
+ }
+ else
+ dest->flags |= k_ent_gate_clean_pass;
+
world_static.current_run_version ++;
}
/* draw lines along the paths */
-VG_STATIC void world_routes_debug( world_instance *world )
+static void world_routes_debug( world_instance *world )
{
for( u32 i=0; i<mdl_arrcount(&world->ent_route_node); i++ ){
ent_route_node *rn = mdl_arritm(&world->ent_route_node,i);
- vg_line_pt3( rn->co, 0.25f, VG__WHITE );
+ vg_line_point( rn->co, 0.25f, VG__WHITE );
}
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
}
}
-VG_STATIC
-void world_routes_pointcloud_spot( world_instance *world,
- pointcloud_buffer *pcbuf,
- v3f co, f32 radius, u32 samples, v4f colour )
-{
- v3f inv_ext;
- v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
- v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
-
- for( u32 j=0; j<samples; j++ ){
- if( pcbuf->count >= pcbuf->max )
- return;
-
- pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
-
- v3f sample, jitter, point;
- vg_rand_sphere( jitter );
- v3_muladds( co, jitter, radius, sample );
-
- if( bh_closest_point( world->geo_bh, sample, point, radius*1.5f ) == -1 ){
- v3_copy( sample, point );
- }
-
- v3f pos;
- v3_sub( point, pcbuf->boundary[0], pos );
- v3_mul( pos, inv_ext, pos );
-
- for( u32 i=0; i<3; i++ ){
- vert->pos[i] = (pos[i]-0.5f) * 32767.0f;
- }
-
- float dist = 1.0f-(v3_length(jitter));
-
- for( u32 i=0; i<4; i++ ){
- vert->colour[i] = colour[i] * 255.0f * dist*dist;
- }
- }
-}
-
-/*
- * '
- * .
- * |
- * |
- * /#\
- * -'###`-
- */
-VG_STATIC
-void world_routes_pointcloud_tower( world_instance *world,
- pointcloud_buffer *pcbuf,
- v3f co, f32 radius, f32 height,
- u32 samples, v4f colour )
-{
- v3f inv_ext;
- v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
- v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
-
- for( u32 j=0; j<samples; j++ ){
- if( pcbuf->count >= pcbuf->max )
- return;
-
- pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
-
- v3f point;
- point[0] = vg_randf64()*2.0f-1.0f;
- point[1] = 0.0f;
- point[2] = vg_randf64()*2.0f-1.0f;
- v3_normalize( point );
- v3_muls( point, sqrtf(vg_randf64()), point );
-
- f32 h = vg_randf64();
- point[1] = h*h*h*height;
- point[0] *= radius;
- point[2] *= radius;
-
- v3_add( point, co, point );
- v3_sub( point, pcbuf->boundary[0], point );
- v3_mul( point, inv_ext, point );
-
- /* TODO....... */
- for( u32 i=0; i<3; i++ ){
- vert->pos[i] = (point[i]-0.5f) * 32767.0f;
- }
-
- for( u32 i=0; i<4; i++ ){
- vert->colour[i] = colour[i] * 255.0f;
- }
- }
-}
-VG_STATIC
+static
void world_routes_place_curve( world_instance *world, ent_route *route,
- v4f h[3], v3f n0, v3f n2, scene_context *scene,
- pointcloud_buffer *pcbuf )
+ v4f h[3], v3f n0, v3f n2, scene_context *scene )
{
float t;
v3f p, pd;
ha.dist = 8.0f;
hb.dist = 8.0f;
- int resa = ray_world( world, sa, down, &ha ),
- resb = ray_world( world, sb, down, &hb );
-
- if( pcbuf && resa ){
- world_routes_pointcloud_spot( world, pcbuf, ha.pos,
- 12.0f, 10, route->colour );
- }
+ int resa = ray_world( world, sa, down, &ha, k_material_flag_ghosts ),
+ resb = ray_world( world, sb, down, &hb, k_material_flag_ghosts );
if( resa && resb ){
struct world_surface *surfa = ray_hit_surface( world, &ha ),
v3_muladds( ha.pos, up, 0.06f+gap, va.co );
v3_muladds( hb.pos, up, 0.06f+gap, vb.co );
- scene_vert_pack_norm( &va, up );
- scene_vert_pack_norm( &vb, up );
+ scene_vert_pack_norm( &va, up, 0.0f );
+ scene_vert_pack_norm( &vb, up, 0.0f );
float t1 = (travel_length / total_length) * patch_count;
va.uv[0] = t1;
}
}
-VG_STATIC void world_routes_gen_meshes( world_instance *world, u32 route_id,
- scene_context *sc,
- pointcloud_buffer *pcbuf )
+static void world_routes_gen_meshes( world_instance *world, u32 route_id,
+ scene_context *sc )
{
ent_route *route = mdl_arritm( &world->ent_route, route_id );
u8 colour[4];
v3_normalize( n0 );
v3_normalize( n2 );
- world_routes_place_curve( world, route, p, n0, n2, sc, pcbuf );
+ world_routes_place_curve( world, route, p, n0, n2, sc );
/* --- */
v4_copy( p[2], p[0] );
scene_copy_slice( sc, &route->sm );
}
-VG_STATIC
+static
struct world_surface *world_tri_index_surface( world_instance *world,
u32 index );
-VG_STATIC f64 world_routes_scatter_surface_points( world_instance *world,
- pointcloud_buffer *pcbuf,
- f32 rate )
-{
- static f32 densities[] = {
- [k_surface_prop_concrete] = 2.0f,
- [k_surface_prop_grass] = 0.8f,
- [k_surface_prop_metal] = 1.0f,
- [k_surface_prop_wood] = 2.5f,
- [k_surface_prop_tiles] = 4.0f
- };
-
- /* calculate total area */
- f64 total_area = 0.0f;
- for( u32 i=0; i<world->scene_geo.indice_count/3; i++ ){
- u32 *tri = &world->scene_geo.arrindices[i*3];
- struct world_surface *surf = world_tri_index_surface( world, tri[0] );
-
- if( surf->info.shader == k_shader_boundary ||
- surf->info.shader == k_shader_invisible ) continue;
-
- if( !(surf->info.flags & k_material_flag_preview_visibile) ) continue;
-
- scene_vert *va = &world->scene_geo.arrvertices[tri[0]],
- *vb = &world->scene_geo.arrvertices[tri[1]],
- *vc = &world->scene_geo.arrvertices[tri[2]];
-
- v3f v0, v1, vn;
- v3_sub( vb->co, va->co, v0 );
- v3_sub( vc->co, va->co, v1 );
- v3_cross( v0, v1, vn );
- if( vn[1] < 0.0f ) continue;
-
- f32 density = 1.0f;
- if( surf->info.surface_prop < vg_list_size(densities) )
- density = densities[surf->info.surface_prop];
- total_area += v3_length(vn)*0.5f*density;
- }
-
- f32 accum = 0.0f;
-
- u8 colour[] = { 80,80,80,255 };
- v3f light_dir = {0.3f,0.8f,0.1f};
- v3_normalize( light_dir );
-
- v3f inv_ext;
- v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
- v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
-
- for( u32 i=0; i<world->scene_geo.indice_count/3; i++ ){
- u32 *tri = &world->scene_geo.arrindices[i*3];
- struct world_surface *surf = world_tri_index_surface( world, tri[0] );
-
- if( surf->info.shader == k_shader_boundary ||
- surf->info.shader == k_shader_invisible ) continue;
-
- if( !(surf->info.flags & k_material_flag_preview_visibile) ) continue;
-
- scene_vert *va = &world->scene_geo.arrvertices[tri[0]],
- *vb = &world->scene_geo.arrvertices[tri[1]],
- *vc = &world->scene_geo.arrvertices[tri[2]];
-
- v3f v0, v1, vn;
- v3_sub( vb->co, va->co, v0 );
- v3_sub( vc->co, va->co, v1 );
- v3_cross( v0, v1, vn );
- if( vn[1] < 0.0f ) continue;
-
- f32 density = 1.0f;
- if( surf->info.surface_prop < vg_list_size(densities) )
- density = densities[surf->info.surface_prop];
-
- f32 area = v3_length(vn)*0.5f*density;
- accum += area;
-
- v3_normalize( vn );
-
- while( accum > rate ){
- accum -= rate;
-
- if( pcbuf->count >= pcbuf->max ) return total_area;
-
- v2f co = { vg_randf64(), vg_randf64() };
- if( v2_length2(co) > 0.5f ){
- co[0] = 1.0f-co[0];
- co[1] = 1.0f-co[1];
- }
-
- v3f pt;
- v3_muls( v0, co[0], pt );
- v3_muladds( pt, v1, co[1], pt );
- v3_add( va->co, pt, pt );
-
- if( pt[1] < world->water.height ) continue;
- pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
-
- v3f pos;
- v3_sub( pt, pcbuf->boundary[0], pos );
- v3_mul( pos, inv_ext, pos );
-
- for( u32 i=0; i<3; i++ ){
- vert->pos[i] = (pos[i]-0.5f) * 32767.0f;
- }
-
- static v4f colours[] = {
- [k_surface_prop_concrete] = { 0.13, 0.15, 0.17, 1.0 },
- [k_surface_prop_grass] = { 0.07, 0.1, 0.14, 1.0 },
- [k_surface_prop_metal] = { 0.15, 0.19, 0.22, 1.0 },
- [k_surface_prop_wood] = { 0.1, 0.13, 0.17, 1.0 },
- [k_surface_prop_tiles] = { 0.05, 0.06, 0.07, 1.0 },
- };
-
- v4f col = {0.0f,0.0f,0.0f,0.0f};
- if( surf->info.surface_prop < vg_list_size(colours) ){
- v4_copy( colours[surf->info.surface_prop], col );
- }
-
- f32 brightness = v3_dot(vn,light_dir)*0.5f+0.5f;
- v3_muls( col, brightness, col );
-
- for( u32 j=0; j<4; j++ ){
- vert->colour[j] = col[j] * 255.0f;
- }
- }
- }
-
- return total_area;
-}
-
-VG_STATIC void world_routes_surface_grid( world_instance *world,
- pointcloud_buffer *pcbuf )
-{
- i32 const k_gridlines = 32,
- k_gridres = 255;
-
- v3f inv_ext;
- v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
- v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
- v4f colour = {0.2f,0.2f,0.2f,1.0f};
- v3f dir = {0.0f,-1.0f,0.0f};
-
- for( u32 k=0; k<2; k++ ){
- u32 a = k*2,
- b = (k^0x1)*2;
-
- for( i32 x=0; x<=k_gridlines; x++ ){
- f32 t = (float)x / (float)k_gridlines,
- px = vg_lerpf( pcbuf->boundary[0][a], pcbuf->boundary[1][a], t );
-
- for( i32 z=0; z<=k_gridres; z++ ){
- f32 tz = (float)z / (float)k_gridres,
- pz = vg_lerpf(pcbuf->boundary[0][b],pcbuf->boundary[1][b], tz);
-
- v3f ro, hit;
- ro[a] = px;
- ro[1] = 1000.0f;
- ro[b] = pz;
-
- bh_iter it;
- bh_iter_init_ray( 0, &it, ro, dir, INFINITY );
- i32 idx;
-
- while( bh_next( world->geo_bh, &it, &idx ) ){
- u32 *tri = &world->scene_geo.arrindices[ idx*3 ];
- v3f vs[3];
-
- for( u32 i=0; i<3; i++ ){
- v3_copy( world->scene_geo.arrvertices[tri[i]].co, vs[i] );
- }
-
- f32 t;
- if( ray_tri( vs, ro, dir, &t ) ){
- v3_muladds( ro, dir, t, hit );
- struct world_surface *m1 =
- world_tri_index_surface( world, tri[0] );
-
- if( !(m1->info.flags & k_material_flag_preview_visibile) )
- continue;
-
- if( world->water.enabled )
- if( hit[1] < world->water.height )
- continue;
-
- if( pcbuf->count >= pcbuf->max ) return;
-
- pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
-
- v3f co;
- v3_sub( hit, pcbuf->boundary[0], co );
- v3_mul( co, inv_ext, co );
-
- for( u32 i=0; i<3; i++ ){
- vert->pos[i] = (co[i]-0.5f) * 32767.0f;
- }
-
- for( u32 i=0; i<4; i++ ){
- vert->colour[i] = colour[i] * 255.0f;
- }
- }
- }
- }
- }
- }
-}
-
/*
* Create the strips of colour that run through the world along course paths
*/
-VG_STATIC void world_gen_routes_generate(void)
-{
- world_instance *world = world_loading_instance();
+static void world_gen_routes_generate( u32 instance_id ){
+ world_instance *world = &world_static.instances[ instance_id ];
vg_info( "Generating route meshes\n" );
vg_async_stall();
&world->mesh_route_lines,
200000, 300000 );
- vg_async_item *call_pointcloud = NULL;
- pointcloud_buffer *pcbuf = NULL;
-
- if( world_loader.generate_point_cloud ){
- call_pointcloud = vg_async_alloc(
- sizeof(pointcloud_buffer) +
- sizeof(pointcloud_vert)*POINTCLOUD_POINTS );
- pcbuf = call_pointcloud->payload;
- pcbuf->count = 0;
- pcbuf->max = POINTCLOUD_POINTS;
- pcbuf->op = k_pointcloud_op_clear;
-
- v3f ext, mid, v0;
- v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], ext );
- f32 maxe = v3_maxf( ext );
- v3_fill( v0, maxe * 0.5f );
- v3_muladds( world->scene_geo.bbx[0], ext, 0.5f, mid );
- v3_add( mid, v0, pcbuf->boundary[1] );
- v3_sub( mid, v0, pcbuf->boundary[0] );
- }
-
for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
ent_gate *gate = mdl_arritm( &world->ent_gate, i );
gate->ref_count = 0;
}
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
- world_routes_gen_meshes( world, i, &world->scene_lines, pcbuf );
- }
-
- if( world_loader.generate_point_cloud ){
- f64 area = 0.0;
- area = world_routes_scatter_surface_points( world, pcbuf, 16.0f );
- world_routes_surface_grid( world, pcbuf );
-
- for( u32 i=0; i<mdl_arrcount( &world->ent_gate ); i++ ){
- ent_gate *gate = mdl_arritm( &world->ent_gate, i );
-
- world_routes_pointcloud_tower( world, pcbuf, gate->co[0],
- 2.0f, 50.0f, 128,
- (v4f){0.2f,0.2f,0.2f,1.0f} );
- }
-
- vg_info( "Distrubuted %u points over %fkm^2!\n",
- pcbuf->count, area/1e6f );
-
- if( world_loader.location == k_world_load_type_local ){
- char path_buf[4096];
- vg_str path;
- vg_strnull( &path, path_buf, 4096 );
- vg_strcat( &path, "maps/" );
- vg_strcat( &path, world_loader.name );
- vg_strcat( &path, "/preview.bin" );
-
- if( !vg_strgood( &path ) ) vg_fatal_error( "Path too long\n" );
- FILE *fp = fopen( path_buf, "wb" );
- if( !fp ) vg_fatal_error( "Cannot open '%s' for writing\n", path_buf );
-
- fwrite( pcbuf, sizeof(pcbuf) +
- sizeof(struct pointcloud_vert)*pcbuf->count, 1, fp );
- fclose( fp );
- }
-
- vg_async_dispatch( call_pointcloud, async_pointcloud_sub );
+ world_routes_gen_meshes( world, i, &world->scene_lines );
}
vg_async_dispatch( call_scene, async_scene_upload );
}
/* load all routes from model header */
-VG_STATIC void world_gen_routes_ent_init(void)
-{
- world_instance *world = world_loading_instance();
+static void world_gen_routes_ent_init( world_instance *world ){
vg_info( "Initializing routes\n" );
for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
ent_route *route = mdl_arritm(&world->ent_route,i);
- mdl_transform_m4x3( &route->transform, route->board_transform );
+ mdl_transform_m4x3( &route->anon.transform, route->board_transform );
- route->official_track_id = 0xffffffff;
+ route->flags = 0x00;
+ route->best_laptime = 0.0;
+ route->ui_stopper = 0.0f;
+ route->ui_residual = 0.0f;
+
+ if( mdl_arrcount(&world->ent_region) )
+ route->flags |= k_ent_route_flag_out_of_zone;
+
+ route->anon.official_track_id = 0xffffffff;
for( u32 j=0; j<vg_list_size(track_infos); j ++ ){
if( !strcmp(track_infos[j].name,
mdl_pstr(&world->meta,route->pstr_name))){
- route->official_track_id = j;
+ route->anon.official_track_id = j;
}
}
}
}
- if( gate->type == k_gate_type_teleport ){
+ if( (gate->flags & k_ent_gate_linked) &
+ !(gate->flags & k_ent_gate_nonlocal) ){
gate = mdl_arritm(&world->ent_gate, gate->target );
for( u32 k=0; k<4; k++ ){
ent_gate *gate = mdl_arritm( &world->ent_gate, i );
}
+ for( u32 i=0; i<mdl_arrcount(&world->ent_checkpoint); i++ ){
+ ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, i );
+ cp->best_time = 0.0;
+ }
+
world_routes_clear( world );
}
+static void world_routes_recv_scoreboard( world_instance *world,
+ vg_msg *body, u32 route_id,
+ enum request_status status ){
+ if( route_id >= mdl_arrcount( &world->ent_route ) ){
+ vg_error( "Scoreboard route_id out of range (%u)\n", route_id );
+ return;
+ }
+
+ struct leaderboard_cache *board = &world->leaderboard_cache[ route_id ];
+ board->status = status;
+
+ if( body == NULL ){
+ board->data_len = 0;
+ return;
+ }
+
+ if( body->max > NETWORK_REQUEST_MAX ){
+ vg_error( "Scoreboard leaderboard too big (%u>%u)\n", body->max,
+ NETWORK_REQUEST_MAX );
+ return;
+ }
+
+ memcpy( board->data, body->buf, body->max );
+ board->data_len = body->max;
+}
+
/*
* -----------------------------------------------------------------------------
* Events
* -----------------------------------------------------------------------------
*/
-VG_STATIC void world_routes_init(void)
-{
+static void world_routes_init(void){
world_static.current_run_version = 200;
world_static.time = 300.0;
world_static.last_use = 0.0;
shader_routeui_register();
}
-VG_STATIC void world_routes_update( world_instance *world )
-{
+static void world_routes_update( world_instance *world ){
world_static.time += vg.time_delta;
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
ent_route *route = mdl_arritm( &world->ent_route, i );
int target = route->active_checkpoint == 0xffff? 0: 1;
- route->factive = vg_lerpf( route->factive, target, 0.6f*vg.time_delta );
+ route->factive = vg_lerpf( route->factive, target,
+ 0.6f*vg.time_frame_delta );
}
for( u32 i=0; i<world_render.text_particle_count; i++ ){
}
}
-VG_STATIC void world_routes_fixedupdate( world_instance *world )
-{
+static void world_routes_fixedupdate( world_instance *world ){
rb_solver_reset();
for( u32 i=0; i<world_render.text_particle_count; i++ ){
int l = rb_sphere__scene( particle->obj.rb.to_world,
&particle->obj.inf.sphere,
- NULL, &world->rb_geo.inf.scene, buf );
+ NULL, &world->rb_geo.inf.scene, buf,
+ k_material_flag_ghosts );
for( int j=0; j<l; j++ ){
buf[j].rba = &particle->obj.rb;
}
}
-VG_STATIC void bind_terrain_noise(void);
-VG_STATIC void world_bind_light_array( world_instance *world,
+static void bind_terrain_noise(void);
+static void world_bind_light_array( world_instance *world,
GLuint shader, GLuint location,
int slot );
-VG_STATIC void world_bind_light_index( world_instance *world,
+static void world_bind_light_index( world_instance *world,
GLuint shader, GLuint location,
int slot );
-VG_STATIC void world_routes_update_timer_texts( world_instance *world )
-{
+static void world_routes_update_timer_texts( world_instance *world ){
world_render.timer_text_count = 0;
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
highscore_intr( text->text+2, route->checkpoints_count+1, 1, ' ' );
text->text[3] = '\0';
}
-
- float align_r = font3d_string_width( &gui.font, 0, text->text );
+
+ gui_font3d.font = &gui.font;
+ float align_r = font3d_string_width( 0, text->text );
align_r *= size;
v3f positions[] = {
positions[0][1] = h1;
}
- m3x3_copy( gate->to_world, text->transform );
+ m4x3f mmdl;
+ ent_gate_get_mdl_mtx( gate, mmdl );
+
+ m3x3_copy( mmdl, text->transform );
float ratio = v3_length(text->transform[0]) /
v3_length(text->transform[1]);
m3x3_scale( text->transform, (v3f){ size, size*ratio, 0.1f } );
- m4x3_mulv( gate->to_world, positions[j], text->transform[3] );
+ m4x3_mulv( mmdl, positions[j], text->transform[3] );
}
}
}
-VG_STATIC void world_routes_fracture( world_instance *world, ent_gate *gate,
+static void world_routes_fracture( world_instance *world, ent_gate *gate,
v3f imp_co, v3f imp_v )
{
world_render.text_particle_count = 0;
}
}
-VG_STATIC void render_world_routes( world_instance *world, camera *cam,
- int layer_depth )
-{
- m4x3f identity_matrix;
- m4x3_identity( identity_matrix );
+static void render_gate_markers( m4x3f world_mmdl, int run_id, ent_gate *gate ){
+ for( u32 j=0; j<4; j++ ){
+ if( gate->routes[j] == run_id ){
+ m4x3f mmdl;
+ m4x3_copy( gate->to_world, mmdl );
+ m3x3_scale( mmdl, (v3f){ gate->dimensions[0],
+ gate->dimensions[1], 1.0f } );
+
+ m4x3_mul( world_mmdl, mmdl, mmdl );
+ shader_model_gate_uMdl( mmdl );
+ mdl_draw_submesh( &world_gates.sm_marker[j] );
+ break;
+ }
+ }
+}
+
+static void render_world_routes( world_instance *world,
+ world_instance *host_world,
+ m4x3f mmdl, camera *cam,
+ int viewing_from_gate, int viewing_from_hub ){
shader_scene_route_use();
shader_scene_route_uTexGarbage(0);
- world_link_lighting_ub( world, _shader_scene_route.id );
- world_bind_position_texture( world, _shader_scene_route.id,
+ world_link_lighting_ub( host_world, _shader_scene_route.id );
+ world_bind_position_texture( host_world, _shader_scene_route.id,
_uniform_scene_route_g_world_depth, 2 );
- world_bind_light_array( world, _shader_scene_route.id,
+ world_bind_light_array( host_world, _shader_scene_route.id,
_uniform_scene_route_uLightsArray, 3 );
- world_bind_light_index( world, _shader_scene_route.id,
+ world_bind_light_index( host_world, _shader_scene_route.id,
_uniform_scene_route_uLightsIndex, 4 );
bind_terrain_noise();
shader_scene_route_uPv( cam->mtx.pv );
- shader_scene_route_uPvmPrev( cam->mtx_prev.pv );
- shader_scene_route_uMdl( identity_matrix );
+
+ if( viewing_from_hub ){
+ m4x4f m4mdl, pvm;
+ m4x3_expand( mmdl, m4mdl );
+ m4x4_mul( cam->mtx_prev.pv, m4mdl, pvm );
+ shader_scene_route_uMdl( mmdl );
+ shader_scene_route_uPvmPrev( pvm );
+
+ m3x3f mnormal;
+ m3x3_inv( mmdl, mnormal );
+ m3x3_transpose( mnormal, mnormal );
+ v3_normalize( mnormal[0] );
+ v3_normalize( mnormal[1] );
+ v3_normalize( mnormal[2] );
+ shader_scene_route_uNormalMtx( mnormal );
+ }
+ else{
+ shader_scene_route_uMdl( mmdl );
+ shader_scene_route_uPvmPrev( cam->mtx_prev.pv );
+ m3x3f ident;
+ m3x3_identity( ident );
+ shader_scene_route_uNormalMtx( ident );
+ }
+
shader_scene_route_uCamera( cam->transform[3] );
mesh_bind( &world->mesh_route_lines );
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
ent_route *route = mdl_arritm( &world->ent_route, i );
+ f32 t = viewing_from_hub? 1.0f: route->factive;
+
v4f colour;
- v3_lerp( (v3f){0.7f,0.7f,0.7f}, route->colour, route->factive, colour );
- colour[3] = route->factive*0.2f;
+ v3_lerp( (v3f){0.7f,0.7f,0.7f}, route->colour, t, colour );
+ colour[3] = t*0.2f;
shader_scene_route_uColour( colour );
mdl_draw_submesh( &route->sm );
/* timers
* ---------------------------------------------------- */
- if( layer_depth == 0 ){
- font3d_bind( &gui.font, cam );
+ if( !viewing_from_gate && !viewing_from_hub ){
+ font3d_bind( &gui.font, k_font_shader_default, 0, world, cam );
for( u32 i=0; i<world_render.timer_text_count; i++ ){
struct timer_text *text = &world_render.timer_texts[i];
colour[3] = 1.0f-text->route->factive;
shader_model_font_uColour( colour );
- font3d_simple_draw( &gui.font, 0, text->text, cam, text->transform );
+ font3d_simple_draw( 0, text->text, cam, text->transform );
}
shader_model_font_uOffset( (v4f){0.0f,0.0f,0.0f,1.0f} );
/* skip writing into the motion vectors for this */
glDrawBuffers( 1, (GLenum[]){ GL_COLOR_ATTACHMENT0 } );
+ glDisable( GL_CULL_FACE );
- for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
- ent_route *route = mdl_arritm( &world->ent_route, i );
+ if( viewing_from_hub ){
+ for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
+ ent_route *route = mdl_arritm( &world->ent_route, i );
- if( route->active_checkpoint != 0xffff ){
v4f colour;
- float brightness = 0.3f + world->ub_lighting.g_day_phase;
- v3_muls( route->colour, brightness, colour );
- colour[3] = 1.0f-route->factive;
+ v3_muls( route->colour, 1.6666f, colour );
+ colour[3] = 0.0f;
shader_model_gate_uColour( colour );
- u32 next = route->active_checkpoint+1+layer_depth;
- next = next % route->checkpoints_count;
- next += route->checkpoints_start;
+ for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
+ ent_gate *gate = mdl_arritm( &world->ent_gate, j );
+ if( !(gate->flags & k_ent_gate_nonlocal) )
+ render_gate_markers( mmdl, i, gate );
+ }
+ }
+ }
+ else{
+ for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
+ ent_route *route = mdl_arritm( &world->ent_route, i );
- ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, next );
- ent_gate *gate = mdl_arritm( &world->ent_gate, cp->gate_index );
- shader_model_gate_uMdl( gate->to_world );
+ if( route->active_checkpoint != 0xffff ){
+ v4f colour;
+ float brightness = 0.3f + world->ub_lighting.g_day_phase;
+ v3_muls( route->colour, brightness, colour );
+ colour[3] = 1.0f-route->factive;
- for( u32 j=0; j<4; j++ ){
- if( gate->routes[j] == i ){
- mdl_draw_submesh( &world_gates.sm_marker[j] );
- break;
- }
+ shader_model_gate_uColour( colour );
+
+ u32 next = route->active_checkpoint+1+viewing_from_gate;
+ next = next % route->checkpoints_count;
+ next += route->checkpoints_start;
+
+ ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, next );
+ ent_gate *gate = mdl_arritm( &world->ent_gate, cp->gate_index );
+ render_gate_markers( mmdl, i, gate );
}
}
}
+ glEnable( GL_CULL_FACE );
glDrawBuffers( 2, (GLenum[]){ GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 } );
}