+#pragma once
+
/*
- * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ * Copyright (C) 2021-2024 Mt.ZERO Software - All Rights Reserved
+ *
+ * World routes
*/
-#ifndef ROUTES_C
-#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 "shaders/scene_route.h"
#include "shaders/routeui.h"
+#include "ent_region.h"
+#include "scene_rigidbody.h"
-static void world_routes_clear( world_instance *world )
+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;
}
-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\n", world_static.current_run_version, world_static.time );
+ vg_info( "%u %f [%s]\n",
+ world_static.current_run_version, world_static.time,
+ !localplayer.rewinded_since_last_gate? "CLEAN": " " );
- if( valid_count==route->checkpoints_count ){
+ if( valid_sections==route->checkpoints_count ){
f64 lap_time = world_static.time - start_time;
- //world_routes_local_set_record( world, route, lap_time );
+ if( (route->best_laptime == 0.0) || (lap_time < route->best_laptime) ){
+ route->best_laptime = lap_time;
+ }
+
+ route->flags |= k_ent_route_flag_achieve_silver;
+ if( clean ) route->flags |= k_ent_route_flag_achieve_gold;
+ ent_region_re_eval( world );
+
+ /* 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 ){
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
*/
-static void world_routes_activate_entry_gate( world_instance *world,
- ent_gate *rg )
+void world_routes_activate_entry_gate( world_instance *world, ent_gate *rg )
{
world_static.last_use = world_static.time;
ent_gate *dest = mdl_arritm( &world->ent_gate, rg->target );
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 ++;
}
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;
scene_copy_slice( sc, &route->sm );
}
-static
struct world_surface *world_tri_index_surface( world_instance *world,
u32 index );
/*
* Create the strips of colour that run through the world along course paths
*/
-static void world_gen_routes_generate( u32 instance_id ){
+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();
- vg_rand_seed( 2000 );
vg_async_item *call_scene = scene_alloc_async( &world->scene_lines,
&world->mesh_route_lines,
200000, 300000 );
}
/* load all routes from model header */
-static void world_gen_routes_ent_init( world_instance *world ){
+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++ ){
ent_route *route = mdl_arritm(&world->ent_route,i);
mdl_transform_m4x3( &route->anon.transform, route->board_transform );
+ 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,
}
if( (gate->flags & k_ent_gate_linked) &
- !(gate->flags & k_ent_gate_nonlocal_DELETED) ){
+ !(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 ){
+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;
* -----------------------------------------------------------------------------
*/
-static void world_routes_init(void){
+void world_routes_init(void)
+{
world_static.current_run_version = 200;
world_static.time = 300.0;
world_static.last_use = 0.0;
-
- shader_scene_route_register();
- shader_routeui_register();
}
-static void world_routes_update( world_instance *world ){
+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) ||
- skaterift.activity == k_skaterift_respawning;
+ int target = route->active_checkpoint == 0xffff? 0: 1;
route->factive = vg_lerpf( route->factive, target,
0.6f*vg.time_frame_delta );
}
for( u32 i=0; i<world_render.text_particle_count; i++ ){
struct text_particle *particle = &world_render.text_particles[i];
- rb_object_debug( &particle->obj, VG__RED );
+ //rb_object_debug( &particle->obj, VG__RED );
}
}
-static void world_routes_fixedupdate( world_instance *world ){
+void world_routes_fixedupdate( world_instance *world )
+{
rb_solver_reset();
+ rigidbody _null = {0};
+ _null.inv_mass = 0.0f;
+ m3x3_zero( _null.iI );
+
for( u32 i=0; i<world_render.text_particle_count; i++ ){
struct text_particle *particle = &world_render.text_particles[i];
if( rb_global_has_space() ){
rb_ct *buf = rb_global_buffer();
- int l = rb_sphere__scene( particle->obj.rb.to_world,
- &particle->obj.inf.sphere,
- NULL, &world->rb_geo.inf.scene, buf,
+ int l = rb_sphere__scene( particle->rb.to_world,
+ particle->radius,
+ NULL, world->geo_bh, buf,
k_material_flag_ghosts );
for( int j=0; j<l; j++ ){
- buf[j].rba = &particle->obj.rb;
- buf[j].rbb = &world->rb_geo.rb;
+ buf[j].rba = &particle->rb;
+ buf[j].rbb = &_null;
}
rb_contact_count += l;
}
}
- rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
+ rb_presolve_contacts( rb_contact_buffer,
+ vg.time_fixed_delta, rb_contact_count );
for( int i=0; i<rb_contact_count; i++ ){
- rb_contact_restitution( rb_contact_buffer+i, vg_randf64() );
+ rb_contact_restitution( rb_contact_buffer+i, vg_randf64(&vg.rand) );
}
for( int i=0; i<6; i++ ){
for( u32 i=0; i<world_render.text_particle_count; i++ ){
struct text_particle *particle = &world_render.text_particles[i];
- rb_iter( &particle->obj.rb );
+ rb_iter( &particle->rb );
}
for( u32 i=0; i<world_render.text_particle_count; i++ ){
struct text_particle *particle = &world_render.text_particles[i];
- rb_update_transform( &particle->obj.rb );
+ rb_update_matrices( &particle->rb );
}
}
-static void bind_terrain_noise(void);
-static void world_bind_light_array( world_instance *world,
- GLuint shader, GLuint location,
- int slot );
-static void world_bind_light_index( world_instance *world,
- GLuint shader, GLuint location,
- int slot );
+void bind_terrain_noise(void);
+void world_bind_light_array( world_instance *world,
+ GLuint shader, GLuint location,
+ int slot );
+void world_bind_light_index( world_instance *world,
+ GLuint shader, GLuint location,
+ int slot );
-static void world_routes_update_timer_texts( world_instance *world ){
+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++ ){
text->gate = gate;
text->route = route;
- if( route->valid_checkpoints >= route->checkpoints_count ){
+ vg_str str;
+ vg_strnull( &str, text->text, sizeof(text->text) );
+
+ if( route->valid_checkpoints >= route->checkpoints_count )
+ {
double lap_time = world_static.time - route->timing_base,
time_centiseconds = lap_time * 100.0;
seconds %= 60;
minutes %= 60;
- if( minutes > 9 ) minutes = 9;
+ if( minutes > 9 )
+ minutes = 9;
- int j=0;
- if( minutes ){
- highscore_intr( text->text, minutes, 1, ' ' ); j++;
- text->text[j++] = ':';
+ if( minutes )
+ {
+ vg_strcati32r( &str, minutes, 1, ' ' );
+ vg_strcatch( &str, ':' );
}
- if( seconds >= 10 || minutes ){
- highscore_intr( text->text+j, seconds, 2, '0' ); j+=2;
+ if( seconds >= 10 || minutes )
+ {
+ vg_strcati32r( &str, seconds, 2, '0' );
}
- else{
- highscore_intr( text->text+j, seconds, 1, '0' ); j++;
+ else
+ {
+ vg_strcati32r( &str, seconds, 1, '0' );
}
- text->text[j++] = '.';
- highscore_intr( text->text+j, centiseconds, 1, '0' ); j++;
- text->text[j] = '\0';
+ vg_strcatch( &str, '.' );
+ vg_strcati32r( &str, centiseconds, 1, '0' );
}
- else{
- highscore_intr( text->text, route->valid_checkpoints, 1, ' ' );
- text->text[1] = '/';
- highscore_intr( text->text+2, route->checkpoints_count+1, 1, ' ' );
- text->text[3] = '\0';
+ else
+ {
+ vg_strcati32r( &str, route->valid_checkpoints, 1, ' ' );
+ vg_strcatch( &str, '/' );
+ vg_strcati32r( &str, route->checkpoints_count + 1, 1, ' ' );
}
gui_font3d.font = &gui.font;
}
}
-static void world_routes_fracture( world_instance *world, ent_gate *gate,
- v3f imp_co, v3f imp_v )
+void world_routes_fracture( world_instance *world, ent_gate *gate,
+ v3f imp_co, v3f imp_v )
{
world_render.text_particle_count = 0;
v3_add( offset, origin, world_co );
m4x3_mulv( transform, world_co, world_co );
- float r = vg_maxf( s[0]*glyph->size[0], s[1]*glyph->size[1] )*0.5f;
m3x3_identity( particle->mlocal );
m3x3_scale( particle->mlocal, s );
origin[2] *= s[2];
v3_muls( origin, -1.0f, particle->mlocal[3] );
- v3_copy( world_co, particle->obj.rb.co );
- v3_muls( imp_v, 1.0f+vg_randf64(), particle->obj.rb.v );
- particle->obj.rb.v[1] += 2.0f;
-
- v4_copy( q, particle->obj.rb.q );
- particle->obj.rb.w[0] = vg_randf64()*2.0f-1.0f;
- particle->obj.rb.w[1] = vg_randf64()*2.0f-1.0f;
- particle->obj.rb.w[2] = vg_randf64()*2.0f-1.0f;
+ v3_copy( world_co, particle->rb.co );
+ v3_muls( imp_v, 1.0f+vg_randf64(&vg.rand), particle->rb.v );
+ particle->rb.v[1] += 2.0f;
- particle->obj.type = k_rb_shape_sphere;
- particle->obj.inf.sphere.radius = r*0.6f;
+ v4_copy( q, particle->rb.q );
+ particle->rb.w[0] = vg_randf64(&vg.rand)*2.0f-1.0f;
+ particle->rb.w[1] = vg_randf64(&vg.rand)*2.0f-1.0f;
+ particle->rb.w[2] = vg_randf64(&vg.rand)*2.0f-1.0f;
- rb_init_object( &particle->obj );
+ f32 r = vg_maxf( s[0]*glyph->size[0], s[1]*glyph->size[1] )*0.5f;
+ particle->radius = r*0.6f;
+ rb_setbody_sphere( &particle->rb, particle->radius, 1.0f, 1.0f );
}
offset[0] += glyph->size[0];
}
}
}
-static void render_gate_markers( int run_id, ent_gate *gate ){
+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;
- ent_gate_get_mdl_mtx( gate, 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, camera *cam,
- int viewing_from_gate ){
- m4x3f identity_matrix;
- m4x3_identity( identity_matrix );
-
+void render_world_routes( world_instance *world,
+ world_instance *host_world,
+ m4x3f mmdl, vg_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( !viewing_from_gate ){
+ 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++ ){
v4f q;
m4x3f model;
- rb_extrapolate( &particle->obj.rb, model[3], q );
+ rb_extrapolate( &particle->rb, model[3], q );
q_m3x3( q, model );
m4x3_mul( model, particle->mlocal, particle->mdl );
glDrawBuffers( 1, (GLenum[]){ GL_COLOR_ATTACHMENT0 } );
glDisable( GL_CULL_FACE );
- if( skaterift.activity == k_skaterift_respawning ){
+ if( viewing_from_hub ){
for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
ent_route *route = mdl_arritm( &world->ent_route, i );
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_DELETED) )
- render_gate_markers( i, gate );
+ if( !(gate->flags & k_ent_gate_nonlocal) )
+ render_gate_markers( mmdl, i, gate );
}
}
}
ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, next );
ent_gate *gate = mdl_arritm( &world->ent_gate, cp->gate_index );
- render_gate_markers( i, gate );
+ render_gate_markers( mmdl, i, gate );
}
}
}
glEnable( GL_CULL_FACE );
glDrawBuffers( 2, (GLenum[]){ GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 } );
}
-
-#endif /* ROUTES_C */