4 * Copyright (C) 2021-2024 Mt.ZERO Software - All Rights Reserved
11 #include "world_routes.h"
12 #include "world_gate.h"
13 #include "world_load.h"
19 #include "network_msg.h"
20 #include "network_common.h"
22 #include "shaders/scene_route.h"
23 #include "shaders/routeui.h"
24 #include "ent_region.h"
25 #include "scene_rigidbody.h"
27 static void world_routes_clear( world_instance
*world
)
29 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_route
); i
++ ){
30 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
31 route
->active_checkpoint
= 0xffff;
34 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_gate
); i
++ ){
35 ent_gate
*rg
= mdl_arritm( &world
->ent_gate
, i
);
36 rg
->timing_version
= 0;
37 rg
->timing_time
= 0.0;
40 world_static
.current_run_version
+= 4;
41 world_static
.last_use
= 0.0;
44 static void world_routes_time_lap( world_instance
*world
, ent_route
*route
){
45 vg_info( "------- time lap %s -------\n",
46 mdl_pstr(&world
->meta
,route
->pstr_name
) );
48 double start_time
= 0.0;
51 ent_checkpoint
*last_cp
= NULL
;
54 int clean
= !localplayer
.rewinded_since_last_gate
;
56 for( u32 i
=0; i
<route
->checkpoints_count
; i
++ ){
57 u32 cpid
= (i
+route
->active_checkpoint
) % route
->checkpoints_count
;
58 cpid
+= route
->checkpoints_start
;
60 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, cpid
);
61 ent_gate
*rg
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
62 rg
= mdl_arritm( &world
->ent_gate
, rg
->target
);
65 route
->timing_base
= rg
->timing_time
;
69 start_time
= rg
->timing_time
;
71 if( last_version
+1 == rg
->timing_version
) valid_sections
++;
72 else valid_sections
= 0;
75 vg_info( "%u %f [%s]\n", rg
->timing_version
, rg
->timing_time
,
76 i
? ((rg
->flags
& k_ent_gate_clean_pass
)? "CLEAN": " "):
79 if( !(rg
->flags
& k_ent_gate_clean_pass
) )
82 last_version
= rg
->timing_version
;
83 last_time
= rg
->timing_time
;
87 if( world_static
.current_run_version
== last_version
+1 ){
90 if( route
->checkpoints_count
== 1 ){
91 route
->timing_base
= world_static
.time
;
94 f32 section
= world_static
.time
- last_time
;
95 if( (section
< last_cp
->best_time
) || (last_cp
->best_time
== 0.0f
) ){
96 last_cp
->best_time
= section
;
99 else valid_sections
= 0;
101 vg_info( "%u %f [%s]\n",
102 world_static
.current_run_version
, world_static
.time
,
103 !localplayer
.rewinded_since_last_gate
? "CLEAN": " " );
105 if( valid_sections
==route
->checkpoints_count
){
106 f64 lap_time
= world_static
.time
- start_time
;
108 if( (route
->best_laptime
== 0.0) || (lap_time
< route
->best_laptime
) ){
109 route
->best_laptime
= lap_time
;
112 route
->flags
|= k_ent_route_flag_achieve_silver
;
113 if( clean
) route
->flags
|= k_ent_route_flag_achieve_gold
;
114 ent_region_re_eval( world
);
116 /* for steam achievements. */
117 if( route
->anon
.official_track_id
!= 0xffffffff ){
118 struct track_info
*ti
= &track_infos
[ route
->anon
.official_track_id
];
119 if( ti
->achievement_id
){
120 steam_set_achievement( ti
->achievement_id
);
121 steam_store_achievements();
126 &world_static
.instance_addons
[ world_static
.active_instance
]->alias
;
128 char mod_uid
[ ADDON_UID_MAX
];
129 addon_alias_uid( alias
, mod_uid
);
130 network_publish_laptime( mod_uid
,
131 mdl_pstr( &world
->meta
, route
->pstr_name
),
135 route
->valid_checkpoints
= valid_sections
+1;
137 vg_info( "valid sections: %u\n", valid_sections
);
138 vg_info( "----------------------------\n" );
140 route
->ui_residual
= 1.0f
;
141 route
->ui_residual_block_w
= route
->ui_first_block_width
;
145 * When going through a gate this is called for bookkeeping purposes
147 static void world_routes_activate_entry_gate( world_instance
*world
,
150 world_static
.last_use
= world_static
.time
;
151 ent_gate
*dest
= mdl_arritm( &world
->ent_gate
, rg
->target
);
153 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
154 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
156 u32 active_prev
= route
->active_checkpoint
;
157 route
->active_checkpoint
= 0xffff;
159 for( u32 j
=0; j
<4; j
++ ){
160 if( dest
->routes
[j
] == i
){
161 for( u32 k
=0; k
<route
->checkpoints_count
; k
++ ){
162 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
,
163 route
->checkpoints_start
+k
);
165 ent_gate
*gk
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
166 gk
= mdl_arritm( &world
->ent_gate
, gk
->target
);
168 route
->active_checkpoint
= k
;
169 world_routes_time_lap( world
, route
);
178 dest
->timing_version
= world_static
.current_run_version
;
179 dest
->timing_time
= world_static
.time
;
181 if( localplayer
.rewinded_since_last_gate
){
182 localplayer
.rewinded_since_last_gate
= 0;
183 dest
->flags
&= ~k_ent_gate_clean_pass
;
186 dest
->flags
|= k_ent_gate_clean_pass
;
188 world_static
.current_run_version
++;
191 /* draw lines along the paths */
192 static void world_routes_debug( world_instance
*world
)
194 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route_node
); i
++ ){
195 ent_route_node
*rn
= mdl_arritm(&world
->ent_route_node
,i
);
196 vg_line_point( rn
->co
, 0.25f
, VG__WHITE
);
199 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
200 ent_route
*route
= mdl_arritm(&world
->ent_route
, i
);
202 u32 colours
[] = { 0xfff58142, 0xff42cbf5, 0xff42f56c, 0xfff542b3,
206 if( route
->active_checkpoint
!= 0xffff ){
207 cc
= colours
[i
%vg_list_size(colours
)];
210 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
211 int i0
= route
->checkpoints_start
+i
,
212 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
214 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
215 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
217 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
218 ent_gate
*end_gate
= mdl_arritm( &world
->ent_gate
, c1
->gate_index
);
221 v3_copy( start_gate
->co
[1], p0
);
223 for( int j
=0; j
<c0
->path_count
; j
++ ){
224 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
227 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
230 v3_copy( rn
->co
, p1
);
231 vg_line( p0
, p1
, cc
);
235 v3_copy( end_gate
->co
[0], p1
);
236 vg_line( p0
, p1
, cc
);
243 void world_routes_place_curve( world_instance
*world
, ent_route
*route
,
244 v4f h
[3], v3f n0
, v3f n2
, scene_context
*scene
)
250 float total_length
= 0.0f
,
254 v3_copy( h
[0], last
);
255 for( int it
=0; it
<128; it
++ ){
256 t
= (float)(it
+1) * (1.0f
/128.0f
);
257 eval_bezier3( h
[0], h
[1], h
[2], t
, p
);
258 total_length
+= v3_dist( p
, last
);
262 float patch_size
= 4.0f
,
263 patch_count
= ceilf( total_length
/ patch_size
);
266 v3_copy( h
[0], last
);
268 for( int it
=0; it
<128; it
++ ){
269 float const k_sample_dist
= 0.0025f
,
272 eval_bezier3( h
[0], h
[1], h
[2], t
, p
);
273 eval_bezier3( h
[0], h
[1], h
[2], t
+k_sample_dist
, pd
);
275 travel_length
+= v3_dist( p
, last
);
277 float mod
= k_sample_dist
/ v3_dist( p
, pd
);
281 v3_muls( n0
, -(1.0f
-t
), up
);
282 v3_muladds( up
, n2
, -t
, up
);
286 v3_cross( up
, v0
, right
);
287 v3_normalize( right
);
289 float cur_x
= (1.0f
-t
)*h
[0][3] + t
*h
[2][3];
291 v3f sc
, sa
, sb
, down
;
292 v3_muladds( p
, right
, cur_x
* k_line_width
, sc
);
293 v3_muladds( sc
, up
, 1.5f
, sc
);
294 v3_muladds( sc
, right
, k_line_width
*0.95f
, sa
);
295 v3_muladds( sc
, right
, 0.0f
, sb
);
296 v3_muls( up
, -1.0f
, down
);
302 int resa
= ray_world( world
, sa
, down
, &ha
, k_material_flag_ghosts
),
303 resb
= ray_world( world
, sb
, down
, &hb
, k_material_flag_ghosts
);
306 struct world_surface
*surfa
= ray_hit_surface( world
, &ha
),
307 *surfb
= ray_hit_surface( world
, &hb
);
309 if( (surfa
->info
.flags
& k_material_flag_skate_target
) &&
310 (surfb
->info
.flags
& k_material_flag_skate_target
) )
314 float gap
= vg_fractf(cur_x
*0.5f
)*0.02f
;
316 v3_muladds( ha
.pos
, up
, 0.06f
+gap
, va
.co
);
317 v3_muladds( hb
.pos
, up
, 0.06f
+gap
, vb
.co
);
319 scene_vert_pack_norm( &va
, up
, 0.0f
);
320 scene_vert_pack_norm( &vb
, up
, 0.0f
);
322 float t1
= (travel_length
/ total_length
) * patch_count
;
328 scene_push_vert( scene
, &va
);
329 scene_push_vert( scene
, &vb
);
332 /* Connect them with triangles */
333 scene_push_tri( scene
, (u32
[3]){
334 last_valid
+0-2, last_valid
+1-2, last_valid
+2-2} );
335 scene_push_tri( scene
, (u32
[3]){
336 last_valid
+1-2, last_valid
+3-2, last_valid
+2-2} );
339 last_valid
= scene
->vertex_count
;
358 static void world_routes_gen_meshes( world_instance
*world
, u32 route_id
,
361 ent_route
*route
= mdl_arritm( &world
->ent_route
, route_id
);
363 colour
[0] = route
->colour
[0] * 255.0f
;
364 colour
[1] = route
->colour
[1] * 255.0f
;
365 colour
[2] = route
->colour
[2] * 255.0f
;
366 colour
[3] = route
->colour
[3] * 255.0f
;
370 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
371 int i0
= route
->checkpoints_start
+i
,
372 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
374 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
375 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
377 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
378 start_gate
= mdl_arritm( &world
->ent_gate
, start_gate
->target
);
380 ent_gate
*end_gate
= mdl_arritm( &world
->ent_gate
, c1
->gate_index
),
381 *collector
= mdl_arritm( &world
->ent_gate
, end_gate
->target
);
385 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, start_gate
->co
[0], p
[0] );
386 p
[0][3] = start_gate
->ref_count
;
387 p
[0][3] -= (float)start_gate
->route_count
* 0.5f
;
388 start_gate
->ref_count
++;
390 if( !c0
->path_count
)
393 /* this is so that we get nice flow through the gates */
394 v3f temp_alignments
[2];
395 ent_gate
*both
[] = { start_gate
, end_gate
};
397 for( int j
=0; j
<2; j
++ ){
398 int pi
= c0
->path_start
+ ((j
==1)? c0
->path_count
-1: 0);
400 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
, pi
);
401 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
404 v3_sub( rn
->co
, both
[j
]->co
[0], v0
);
405 float d
= v3_dot( v0
, both
[j
]->to_world
[2] );
407 v3_muladds( both
[j
]->co
[0], both
[j
]->to_world
[2], d
,
408 temp_alignments
[j
] );
409 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, temp_alignments
[j
], temp_alignments
[j
]);
413 for( int j
=0; j
<c0
->path_count
; j
++ ){
414 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
416 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
418 if( j
==0 || j
==c0
->path_count
-1 )
420 v3_copy( temp_alignments
[0], p
[1] );
422 v3_copy( temp_alignments
[1], p
[1] );
424 v3_copy( rn
->co
, p
[1] );
426 p
[1][3] = rn
->ref_count
;
427 p
[1][3] -= (float)rn
->ref_total
* 0.5f
;
430 if( j
+1 < c0
->path_count
){
431 index
= mdl_arritm( &world
->ent_path_index
,
432 c0
->path_start
+j
+1 );
433 rn
= mdl_arritm( &world
->ent_route_node
, index
->index
);
435 if( j
+1 == c0
->path_count
-1 )
436 v3_lerp( p
[1], temp_alignments
[1], 0.5f
, p
[2] );
438 v3_lerp( p
[1], rn
->co
, 0.5f
, p
[2] );
440 p
[2][3] = rn
->ref_count
;
441 p
[2][3] -= (float)rn
->ref_total
* 0.5f
;
444 v3_copy( end_gate
->co
[0], p
[2] );
445 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, p
[2], p
[2] );
446 p
[2][3] = collector
->ref_count
;
448 if( i
== route
->checkpoints_count
-1)
451 p
[2][3] -= (float)collector
->route_count
* 0.5f
;
452 //collector->ref_count ++;
455 /* p0,p1,p2 bezier patch is complete
456 * --------------------------------------*/
457 v3f surf0
, surf2
, n0
, n2
;
459 if( bh_closest_point( world
->geo_bh
, p
[0], surf0
, 5.0f
) == -1 )
460 v3_add( (v3f
){0.0f
,-0.1f
,0.0f
}, p
[0], surf0
);
462 if( bh_closest_point( world
->geo_bh
, p
[2], surf2
, 5.0f
) == -1 )
463 v3_add( (v3f
){0.0f
,-0.1f
,0.0f
}, p
[2], surf2
);
465 v3_sub( surf0
, p
[0], n0
);
466 v3_sub( surf2
, p
[2], n2
);
470 world_routes_place_curve( world
, route
, p
, n0
, n2
, sc
);
473 v4_copy( p
[2], p
[0] );
477 scene_copy_slice( sc
, &route
->sm
);
481 struct world_surface
*world_tri_index_surface( world_instance
*world
,
485 * Create the strips of colour that run through the world along course paths
487 static void world_gen_routes_generate( u32 instance_id
){
488 world_instance
*world
= &world_static
.instances
[ instance_id
];
489 vg_info( "Generating route meshes\n" );
492 vg_async_item
*call_scene
= scene_alloc_async( &world
->scene_lines
,
493 &world
->mesh_route_lines
,
496 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
497 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
499 gate
->route_count
= 0;
502 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route_node
); i
++ ){
503 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
, i
);
508 for( u32 k
=0; k
<mdl_arrcount(&world
->ent_route
); k
++ ){
509 ent_route
*route
= mdl_arritm( &world
->ent_route
, k
);
511 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
512 int i0
= route
->checkpoints_start
+i
,
513 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
515 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
516 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
518 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
519 start_gate
= mdl_arritm( &world
->ent_gate
, start_gate
->target
);
520 start_gate
->route_count
++;
522 if( !c0
->path_count
)
525 for( int j
=0; j
<c0
->path_count
; j
++ ){
526 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
528 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
535 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
536 world_routes_gen_meshes( world
, i
, &world
->scene_lines
);
539 vg_async_dispatch( call_scene
, async_scene_upload
);
540 world_routes_clear( world
);
543 /* load all routes from model header */
544 static void world_gen_routes_ent_init( world_instance
*world
){
545 vg_info( "Initializing routes\n" );
547 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
548 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
549 for( u32 j
=0; j
<4; j
++ ){
550 gate
->routes
[j
] = 0xffff;
554 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
555 ent_route
*route
= mdl_arritm(&world
->ent_route
,i
);
556 mdl_transform_m4x3( &route
->anon
.transform
, route
->board_transform
);
559 route
->best_laptime
= 0.0;
560 route
->ui_stopper
= 0.0f
;
561 route
->ui_residual
= 0.0f
;
563 if( mdl_arrcount(&world
->ent_region
) )
564 route
->flags
|= k_ent_route_flag_out_of_zone
;
566 route
->anon
.official_track_id
= 0xffffffff;
567 for( u32 j
=0; j
<vg_list_size(track_infos
); j
++ ){
568 if( !strcmp(track_infos
[j
].name
,
569 mdl_pstr(&world
->meta
,route
->pstr_name
))){
570 route
->anon
.official_track_id
= j
;
574 for( u32 j
=0; j
<route
->checkpoints_count
; j
++ ){
575 u32 id
= route
->checkpoints_start
+ j
;
576 ent_checkpoint
*cp
= mdl_arritm(&world
->ent_checkpoint
,id
);
578 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
580 for( u32 k
=0; k
<4; k
++ ){
581 if( gate
->routes
[k
] == 0xffff ){
587 if( (gate
->flags
& k_ent_gate_linked
) &
588 !(gate
->flags
& k_ent_gate_nonlocal
) ){
589 gate
= mdl_arritm(&world
->ent_gate
, gate
->target
);
591 for( u32 k
=0; k
<4; k
++ ){
592 if( gate
->routes
[k
] == i
){
593 vg_error( "already assigned route to gate\n" );
596 if( gate
->routes
[k
] == 0xffff ){
605 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
606 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
609 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_checkpoint
); i
++ ){
610 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, i
);
614 world_routes_clear( world
);
617 static void world_routes_recv_scoreboard( world_instance
*world
,
618 vg_msg
*body
, u32 route_id
,
619 enum request_status status
){
620 if( route_id
>= mdl_arrcount( &world
->ent_route
) ){
621 vg_error( "Scoreboard route_id out of range (%u)\n", route_id
);
625 struct leaderboard_cache
*board
= &world
->leaderboard_cache
[ route_id
];
626 board
->status
= status
;
633 if( body
->max
> NETWORK_REQUEST_MAX
){
634 vg_error( "Scoreboard leaderboard too big (%u>%u)\n", body
->max
,
635 NETWORK_REQUEST_MAX
);
639 memcpy( board
->data
, body
->buf
, body
->max
);
640 board
->data_len
= body
->max
;
644 * -----------------------------------------------------------------------------
646 * -----------------------------------------------------------------------------
649 static void world_routes_init(void){
650 world_static
.current_run_version
= 200;
651 world_static
.time
= 300.0;
652 world_static
.last_use
= 0.0;
654 shader_scene_route_register();
655 shader_routeui_register();
658 static void world_routes_update( world_instance
*world
){
659 world_static
.time
+= vg
.time_delta
;
661 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
662 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
664 int target
= route
->active_checkpoint
== 0xffff? 0: 1;
665 route
->factive
= vg_lerpf( route
->factive
, target
,
666 0.6f
*vg
.time_frame_delta
);
669 for( u32 i
=0; i
<world_render
.text_particle_count
; i
++ ){
670 struct text_particle
*particle
= &world_render
.text_particles
[i
];
671 //rb_object_debug( &particle->obj, VG__RED );
675 static void world_routes_fixedupdate( world_instance
*world
){
678 rigidbody _null
= {0};
679 _null
.inv_mass
= 0.0f
;
680 m3x3_zero( _null
.iI
);
682 for( u32 i
=0; i
<world_render
.text_particle_count
; i
++ ){
683 struct text_particle
*particle
= &world_render
.text_particles
[i
];
685 if( rb_global_has_space() ){
686 rb_ct
*buf
= rb_global_buffer();
688 int l
= rb_sphere__scene( particle
->rb
.to_world
,
690 NULL
, world
->geo_bh
, buf
,
691 k_material_flag_ghosts
);
693 for( int j
=0; j
<l
; j
++ ){
694 buf
[j
].rba
= &particle
->rb
;
698 rb_contact_count
+= l
;
702 rb_presolve_contacts( rb_contact_buffer
, rb_contact_count
);
704 for( int i
=0; i
<rb_contact_count
; i
++ ){
705 rb_contact_restitution( rb_contact_buffer
+i
, vg_randf64(&vg
.rand
) );
708 for( int i
=0; i
<6; i
++ ){
709 rb_solve_contacts( rb_contact_buffer
, rb_contact_count
);
712 for( u32 i
=0; i
<world_render
.text_particle_count
; i
++ ){
713 struct text_particle
*particle
= &world_render
.text_particles
[i
];
714 rb_iter( &particle
->rb
);
717 for( u32 i
=0; i
<world_render
.text_particle_count
; i
++ ){
718 struct text_particle
*particle
= &world_render
.text_particles
[i
];
719 rb_update_matrices( &particle
->rb
);
723 static void bind_terrain_noise(void);
724 static void world_bind_light_array( world_instance
*world
,
725 GLuint shader
, GLuint location
,
727 static void world_bind_light_index( world_instance
*world
,
728 GLuint shader
, GLuint location
,
731 static void world_routes_update_timer_texts( world_instance
*world
){
732 world_render
.timer_text_count
= 0;
734 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
735 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
737 if( route
->active_checkpoint
!= 0xffff ){
738 u32 next
= route
->active_checkpoint
+1;
739 next
= next
% route
->checkpoints_count
;
740 next
+= route
->checkpoints_start
;
742 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, next
);
743 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
744 ent_gate
*dest
= mdl_arritm( &world
->ent_gate
, gate
->target
);
748 if( dest
->routes
[j
] == i
){
758 struct timer_text
*text
=
759 &world_render
.timer_texts
[ world_render
.timer_text_count
++ ];
765 vg_strnull( &str
, text
->text
, sizeof(text
->text
) );
767 if( route
->valid_checkpoints
>= route
->checkpoints_count
)
769 double lap_time
= world_static
.time
- route
->timing_base
,
770 time_centiseconds
= lap_time
* 100.0;
772 if( time_centiseconds
> (float)0xfffe ) time_centiseconds
= 0.0;
774 u16 centiseconds
= time_centiseconds
,
775 seconds
= centiseconds
/ 100,
776 minutes
= seconds
/ 60;
787 vg_strcati32r( &str
, minutes
, 1, ' ' );
788 vg_strcatch( &str
, ':' );
791 if( seconds
>= 10 || minutes
)
793 vg_strcati32r( &str
, seconds
, 2, '0' );
797 vg_strcati32r( &str
, seconds
, 1, '0' );
800 vg_strcatch( &str
, '.' );
801 vg_strcati32r( &str
, centiseconds
, 1, '0' );
805 vg_strcati32r( &str
, route
->valid_checkpoints
, 1, ' ' );
806 vg_strcatch( &str
, '/' );
807 vg_strcati32r( &str
, route
->checkpoints_count
+ 1, 1, ' ' );
810 gui_font3d
.font
= &gui
.font
;
811 float align_r
= font3d_string_width( 0, text
->text
);
815 { -0.92f
, h0
, depth
},
816 { 0.92f
- align_r
, h0
, depth
},
817 { -0.92f
, h1
, depth
},
818 { 0.92f
- align_r
, h1
, depth
},
821 if( dest
->route_count
== 1 ){
822 positions
[0][0] = -align_r
*0.5f
;
823 positions
[0][1] = h1
;
827 ent_gate_get_mdl_mtx( gate
, mmdl
);
829 m3x3_copy( mmdl
, text
->transform
);
830 float ratio
= v3_length(text
->transform
[0]) /
831 v3_length(text
->transform
[1]);
833 m3x3_scale( text
->transform
, (v3f
){ size
, size
*ratio
, 0.1f
} );
834 m4x3_mulv( mmdl
, positions
[j
], text
->transform
[3] );
839 static void world_routes_fracture( world_instance
*world
, ent_gate
*gate
,
840 v3f imp_co
, v3f imp_v
)
842 world_render
.text_particle_count
= 0;
844 for( u32 i
=0; i
<world_render
.timer_text_count
; i
++ ){
845 struct timer_text
*text
= &world_render
.timer_texts
[i
];
847 if( text
->gate
!= gate
) continue;
850 m4x3_mul( gate
->transport
, text
->transform
, transform
);
854 m4x3_decompose( transform
, co
, q
, s
);
860 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
861 v3_muls( text
->route
->colour
, brightness
, colour
);
862 colour
[3] = 1.0f
-text
->route
->factive
;
864 for( u32 j
=0;; j
++ ){
865 char c
= text
->text
[j
];
868 ent_glyph
*glyph
= font3d_glyph( &gui
.font
, 0, c
);
869 if( !glyph
) continue;
871 if( c
>= (u32
)'0' && c
<= (u32
)'9' && glyph
->indice_count
){
872 struct text_particle
*particle
=
873 &world_render
.text_particles
[world_render
.text_particle_count
++];
875 particle
->glyph
= glyph
;
876 v4_copy( colour
, particle
->colour
);
879 v2_muls( glyph
->size
, 0.5f
, origin
);
884 v3_add( offset
, origin
, world_co
);
885 m4x3_mulv( transform
, world_co
, world_co
);
888 m3x3_identity( particle
->mlocal
);
889 m3x3_scale( particle
->mlocal
, s
);
891 v3_muls( origin
, -1.0f
, particle
->mlocal
[3] );
893 v3_copy( world_co
, particle
->rb
.co
);
894 v3_muls( imp_v
, 1.0f
+vg_randf64(&vg
.rand
), particle
->rb
.v
);
895 particle
->rb
.v
[1] += 2.0f
;
897 v4_copy( q
, particle
->rb
.q
);
898 particle
->rb
.w
[0] = vg_randf64(&vg
.rand
)*2.0f
-1.0f
;
899 particle
->rb
.w
[1] = vg_randf64(&vg
.rand
)*2.0f
-1.0f
;
900 particle
->rb
.w
[2] = vg_randf64(&vg
.rand
)*2.0f
-1.0f
;
902 f32 r
= vg_maxf( s
[0]*glyph
->size
[0], s
[1]*glyph
->size
[1] )*0.5f
;
903 particle
->radius
= r
*0.6f
;
904 rb_setbody_sphere( &particle
->rb
, particle
->radius
, 1.0f
, 1.0f
);
906 offset
[0] += glyph
->size
[0];
911 static void render_gate_markers( m4x3f world_mmdl
, int run_id
, ent_gate
*gate
){
912 for( u32 j
=0; j
<4; j
++ ){
913 if( gate
->routes
[j
] == run_id
){
915 m4x3_copy( gate
->to_world
, mmdl
);
916 m3x3_scale( mmdl
, (v3f
){ gate
->dimensions
[0],
917 gate
->dimensions
[1], 1.0f
} );
919 m4x3_mul( world_mmdl
, mmdl
, mmdl
);
920 shader_model_gate_uMdl( mmdl
);
921 mdl_draw_submesh( &world_gates
.sm_marker
[j
] );
927 static void render_world_routes( world_instance
*world
,
928 world_instance
*host_world
,
929 m4x3f mmdl
, camera
*cam
,
930 int viewing_from_gate
, int viewing_from_hub
){
932 shader_scene_route_use();
933 shader_scene_route_uTexGarbage(0);
934 world_link_lighting_ub( host_world
, _shader_scene_route
.id
);
935 world_bind_position_texture( host_world
, _shader_scene_route
.id
,
936 _uniform_scene_route_g_world_depth
, 2 );
937 world_bind_light_array( host_world
, _shader_scene_route
.id
,
938 _uniform_scene_route_uLightsArray
, 3 );
939 world_bind_light_index( host_world
, _shader_scene_route
.id
,
940 _uniform_scene_route_uLightsIndex
, 4 );
941 bind_terrain_noise();
943 shader_scene_route_uPv( cam
->mtx
.pv
);
945 if( viewing_from_hub
){
947 m4x3_expand( mmdl
, m4mdl
);
948 m4x4_mul( cam
->mtx_prev
.pv
, m4mdl
, pvm
);
949 shader_scene_route_uMdl( mmdl
);
950 shader_scene_route_uPvmPrev( pvm
);
953 m3x3_inv( mmdl
, mnormal
);
954 m3x3_transpose( mnormal
, mnormal
);
955 v3_normalize( mnormal
[0] );
956 v3_normalize( mnormal
[1] );
957 v3_normalize( mnormal
[2] );
958 shader_scene_route_uNormalMtx( mnormal
);
961 shader_scene_route_uMdl( mmdl
);
962 shader_scene_route_uPvmPrev( cam
->mtx_prev
.pv
);
964 m3x3_identity( ident
);
965 shader_scene_route_uNormalMtx( ident
);
968 shader_scene_route_uCamera( cam
->transform
[3] );
970 mesh_bind( &world
->mesh_route_lines
);
972 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
973 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
975 f32 t
= viewing_from_hub
? 1.0f
: route
->factive
;
978 v3_lerp( (v3f
){0.7f
,0.7f
,0.7f
}, route
->colour
, t
, colour
);
981 shader_scene_route_uColour( colour
);
982 mdl_draw_submesh( &route
->sm
);
986 * ---------------------------------------------------- */
987 if( !viewing_from_gate
&& !viewing_from_hub
){
988 font3d_bind( &gui
.font
, k_font_shader_default
, 0, world
, cam
);
990 for( u32 i
=0; i
<world_render
.timer_text_count
; i
++ ){
991 struct timer_text
*text
= &world_render
.timer_texts
[i
];
994 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
995 v3_muls( text
->route
->colour
, brightness
, colour
);
996 colour
[3] = 1.0f
-text
->route
->factive
;
998 shader_model_font_uColour( colour
);
999 font3d_simple_draw( 0, text
->text
, cam
, text
->transform
);
1002 shader_model_font_uOffset( (v4f
){0.0f
,0.0f
,0.0f
,1.0f
} );
1004 for( u32 i
=0; i
<world_render
.text_particle_count
; i
++ ){
1005 struct text_particle
*particle
= &world_render
.text_particles
[i
];
1009 m4x3_expand( particle
->mdl
, prev_mtx
);
1010 m4x4_mul( cam
->mtx_prev
.pv
, prev_mtx
, prev_mtx
);
1012 shader_model_font_uPvmPrev( prev_mtx
);
1016 rb_extrapolate( &particle
->rb
, model
[3], q
);
1019 m4x3_mul( model
, particle
->mlocal
, particle
->mdl
);
1020 shader_model_font_uMdl( particle
->mdl
);
1021 shader_model_font_uColour( particle
->colour
);
1023 mesh_drawn( particle
->glyph
->indice_start
,
1024 particle
->glyph
->indice_count
);
1029 * ---------------------------------------------------- */
1031 shader_model_gate_use();
1032 shader_model_gate_uPv( cam
->mtx
.pv
);
1033 shader_model_gate_uCam( cam
->pos
);
1034 shader_model_gate_uTime( vg
.time
*0.25f
);
1035 shader_model_gate_uInvRes( (v2f
){
1036 1.0f
/ (float)vg
.window_x
,
1037 1.0f
/ (float)vg
.window_y
});
1039 mesh_bind( &world_gates
.mesh
);
1041 /* skip writing into the motion vectors for this */
1042 glDrawBuffers( 1, (GLenum
[]){ GL_COLOR_ATTACHMENT0
} );
1043 glDisable( GL_CULL_FACE
);
1045 if( viewing_from_hub
){
1046 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
1047 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
1050 v3_muls( route
->colour
, 1.6666f
, colour
);
1053 shader_model_gate_uColour( colour
);
1055 for( u32 j
=0; j
<mdl_arrcount(&world
->ent_gate
); j
++ ){
1056 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, j
);
1057 if( !(gate
->flags
& k_ent_gate_nonlocal
) )
1058 render_gate_markers( mmdl
, i
, gate
);
1063 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
1064 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
1066 if( route
->active_checkpoint
!= 0xffff ){
1068 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
1069 v3_muls( route
->colour
, brightness
, colour
);
1070 colour
[3] = 1.0f
-route
->factive
;
1072 shader_model_gate_uColour( colour
);
1074 u32 next
= route
->active_checkpoint
+1+viewing_from_gate
;
1075 next
= next
% route
->checkpoints_count
;
1076 next
+= route
->checkpoints_start
;
1078 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, next
);
1079 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
1080 render_gate_markers( mmdl
, i
, gate
);
1084 glEnable( GL_CULL_FACE
);
1085 glDrawBuffers( 2, (GLenum
[]){ GL_COLOR_ATTACHMENT0
, GL_COLOR_ATTACHMENT1
} );