2 * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
10 #include "world_gate.h"
14 #include "shaders/vblend.h"
17 #include "shaders/scene_route.h"
18 #include "shaders/routeui.h"
22 void world_routes_local_set_record( world_instance
*world
, ent_route
*route
,
25 vg_success( " NEW LAP TIME: %f\n", lap_time
);
27 if( route
->official_track_id
!= 0xffffffff ){
28 double time_centiseconds
= lap_time
* 100.0;
29 if( time_centiseconds
> (float)0xfffe ) /* skill issue */
32 highscore_record temp
;
33 temp
.trackid
= route
->official_track_id
;
34 temp
.datetime
= time(NULL
);
37 temp
.time
= time_centiseconds
;
40 highscores_push_record( &temp
);
43 struct track_info
*ti
= &track_infos
[ route
->official_track_id
];
46 if( ti
->achievement_id
){
48 steam_set_achievement( ti
->achievement_id
);
49 steam_store_achievements();
54 vg_warn( "There is no associated track for this record...\n" );
59 VG_STATIC
void world_routes_clear( world_instance
*world
)
61 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_route
); i
++ ){
62 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
63 route
->active_checkpoint
= 0xffff;
66 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_gate
); i
++ ){
67 ent_gate
*rg
= mdl_arritm( &world
->ent_gate
, i
);
68 rg
->timing_version
= 0;
69 rg
->timing_time
= 0.0;
72 world_global
.current_run_version
+= 4;
73 world_global
.last_use
= 0.0;
76 VG_STATIC
void world_routes_time_lap( world_instance
*world
, ent_route
*route
)
78 vg_info( "------- time lap %s -------\n",
79 mdl_pstr(&world
->meta
,route
->pstr_name
) );
81 double start_time
= 0.0;
86 for( u32 i
=0; i
<route
->checkpoints_count
; i
++ ){
87 u32 cpid
= (i
+route
->active_checkpoint
) % route
->checkpoints_count
;
88 cpid
+= route
->checkpoints_start
;
90 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, cpid
);
91 ent_gate
*rg
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
92 rg
= mdl_arritm( &world
->ent_gate
, rg
->target
);
95 route
->timing_base
= rg
->timing_time
;
99 start_time
= rg
->timing_time
;
101 if( last_version
+1 == rg
->timing_version
) valid_count
++;
102 else valid_count
= 0;
105 last_version
= rg
->timing_version
;
106 vg_info( "%u %f\n", rg
->timing_version
, rg
->timing_time
);
109 if( world_global
.current_run_version
== last_version
+1 ){
112 if( route
->checkpoints_count
== 1 ){
113 route
->timing_base
= world_global
.time
;
116 else valid_count
= 0;
118 vg_info( "%u %f\n", world_global
.current_run_version
, world_global
.time
);
120 if( valid_count
==route
->checkpoints_count
){
121 double lap_time
= world_global
.time
- start_time
;
122 world_routes_local_set_record( world
, route
, lap_time
);
125 route
->valid_checkpoints
= valid_count
+1;
127 vg_info( "valid: %u\n", valid_count
);
128 vg_info( "----------------------------\n" );
132 * When going through a gate this is called for bookkeeping purposes
134 VG_STATIC
void world_routes_activate_entry_gate( world_instance
*world
,
137 world_global
.last_use
= world_global
.time
;
139 /* disable all routes and leave the world */
140 if( rg
->type
== k_gate_type_nonlocel
){
141 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
142 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
143 route
->active_checkpoint
= 0xffff;
148 ent_gate
*dest
= mdl_arritm( &world
->ent_gate
, rg
->target
);
150 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
151 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
153 u32 active_prev
= route
->active_checkpoint
;
154 route
->active_checkpoint
= 0xffff;
156 for( u32 j
=0; j
<4; j
++ ){
157 if( dest
->routes
[j
] == i
){
158 for( u32 k
=0; k
<route
->checkpoints_count
; k
++ ){
159 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
,
160 route
->checkpoints_start
+k
);
162 ent_gate
*gk
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
163 gk
= mdl_arritm( &world
->ent_gate
, gk
->target
);
165 route
->active_checkpoint
= k
;
166 world_routes_time_lap( world
, route
);
175 dest
->timing_version
= world_global
.current_run_version
;
176 dest
->timing_time
= world_global
.time
;
178 world_global
.current_run_version
++;
181 /* draw lines along the paths */
182 VG_STATIC
void world_routes_debug( world_instance
*world
)
184 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route_node
); i
++ ){
185 ent_route_node
*rn
= mdl_arritm(&world
->ent_route_node
,i
);
186 vg_line_pt3( rn
->co
, 0.25f
, VG__WHITE
);
189 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
190 ent_route
*route
= mdl_arritm(&world
->ent_route
, i
);
192 u32 colours
[] = { 0xfff58142, 0xff42cbf5, 0xff42f56c, 0xfff542b3,
196 if( route
->active_checkpoint
!= 0xffff ){
197 cc
= colours
[i
%vg_list_size(colours
)];
200 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
201 int i0
= route
->checkpoints_start
+i
,
202 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
204 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
205 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
207 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
208 ent_gate
*end_gate
= mdl_arritm( &world
->ent_gate
, c1
->gate_index
);
211 v3_copy( start_gate
->co
[1], p0
);
213 for( int j
=0; j
<c0
->path_count
; j
++ ){
214 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
217 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
220 v3_copy( rn
->co
, p1
);
221 vg_line( p0
, p1
, cc
);
225 v3_copy( end_gate
->co
[0], p1
);
226 vg_line( p0
, p1
, cc
);
231 VG_STATIC
void world_routes_place_curve( world_instance
*world
,
232 v4f h
[3], v3f n0
, v3f n2
)
238 float total_length
= 0.0f
,
242 v3_copy( h
[0], last
);
243 for( int it
=0; it
<128; it
++ ){
244 t
= (float)(it
+1) * (1.0f
/128.0f
);
245 eval_bezier3( h
[0], h
[1], h
[2], t
, p
);
246 total_length
+= v3_dist( p
, last
);
250 float patch_size
= 4.0f
,
251 patch_count
= ceilf( total_length
/ patch_size
);
254 v3_copy( h
[0], last
);
256 for( int it
=0; it
<128; it
++ ){
257 float const k_sample_dist
= 0.0025f
,
260 eval_bezier3( h
[0], h
[1], h
[2], t
, p
);
261 eval_bezier3( h
[0], h
[1], h
[2], t
+k_sample_dist
, pd
);
263 travel_length
+= v3_dist( p
, last
);
265 float mod
= k_sample_dist
/ v3_dist( p
, pd
);
269 v3_muls( n0
, -(1.0f
-t
), up
);
270 v3_muladds( up
, n2
, -t
, up
);
274 v3_cross( up
, v0
, right
);
275 v3_normalize( right
);
277 float cur_x
= (1.0f
-t
)*h
[0][3] + t
*h
[2][3];
279 v3f sc
, sa
, sb
, down
;
280 v3_muladds( p
, right
, cur_x
* k_line_width
, sc
);
281 v3_muladds( sc
, up
, 1.5f
, sc
);
282 v3_muladds( sc
, right
, k_line_width
*0.95f
, sa
);
283 v3_muladds( sc
, right
, 0.0f
, sb
);
284 v3_muls( up
, -1.0f
, down
);
290 int resa
= ray_world( world
, sa
, down
, &ha
),
291 resb
= ray_world( world
, sb
, down
, &hb
);
294 struct world_surface
*surfa
= ray_hit_surface( world
, &ha
),
295 *surfb
= ray_hit_surface( world
, &hb
);
297 if( (surfa
->info
.flags
& k_material_flag_skate_target
) &&
298 (surfb
->info
.flags
& k_material_flag_skate_target
) )
302 float gap
= vg_fractf(cur_x
*0.5f
)*0.02f
;
304 v3_muladds( ha
.pos
, up
, 0.06f
+gap
, va
.co
);
305 v3_muladds( hb
.pos
, up
, 0.06f
+gap
, vb
.co
);
307 scene_vert_pack_norm( &va
, up
);
308 scene_vert_pack_norm( &vb
, up
);
310 float t1
= (travel_length
/ total_length
) * patch_count
;
316 scene_push_vert( world
->scene_lines
, &va
);
317 scene_push_vert( world
->scene_lines
, &vb
);
320 /* Connect them with triangles */
321 scene_push_tri( world
->scene_lines
, (u32
[3]){
322 last_valid
+0-2, last_valid
+1-2, last_valid
+2-2} );
323 scene_push_tri( world
->scene_lines
, (u32
[3]){
324 last_valid
+1-2, last_valid
+3-2, last_valid
+2-2} );
327 last_valid
= world
->scene_lines
->vertex_count
;
346 VG_STATIC
void world_routes_create_mesh( world_instance
*world
, u32 route_id
)
348 ent_route
*route
= mdl_arritm( &world
->ent_route
, route_id
);
351 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
352 int i0
= route
->checkpoints_start
+i
,
353 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
355 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
356 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
358 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
359 start_gate
= mdl_arritm( &world
->ent_gate
, start_gate
->target
);
361 ent_gate
*end_gate
= mdl_arritm( &world
->ent_gate
, c1
->gate_index
),
362 *collector
= mdl_arritm( &world
->ent_gate
, end_gate
->target
);
366 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, start_gate
->co
[0], p
[0] );
367 p
[0][3] = start_gate
->ref_count
;
368 p
[0][3] -= (float)start_gate
->route_count
* 0.5f
;
369 start_gate
->ref_count
++;
371 if( !c0
->path_count
)
374 /* this is so that we get nice flow through the gates */
375 v3f temp_alignments
[2];
376 ent_gate
*both
[] = { start_gate
, end_gate
};
378 for( int j
=0; j
<2; j
++ ){
379 int pi
= c0
->path_start
+ ((j
==1)? c0
->path_count
-1: 0);
381 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
, pi
);
382 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
385 v3_sub( rn
->co
, both
[j
]->co
[0], v0
);
386 float d
= v3_dot( v0
, both
[j
]->to_world
[2] );
388 v3_muladds( both
[j
]->co
[0], both
[j
]->to_world
[2], d
,
389 temp_alignments
[j
] );
390 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, temp_alignments
[j
], temp_alignments
[j
]);
394 for( int j
=0; j
<c0
->path_count
; j
++ ){
395 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
397 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
399 if( j
==0 || j
==c0
->path_count
-1 )
401 v3_copy( temp_alignments
[0], p
[1] );
403 v3_copy( temp_alignments
[1], p
[1] );
405 v3_copy( rn
->co
, p
[1] );
407 p
[1][3] = rn
->ref_count
;
408 p
[1][3] -= (float)rn
->ref_total
* 0.5f
;
411 if( j
+1 < c0
->path_count
){
412 index
= mdl_arritm( &world
->ent_path_index
,
413 c0
->path_start
+j
+1 );
414 rn
= mdl_arritm( &world
->ent_route_node
, index
->index
);
416 if( j
+1 == c0
->path_count
-1 )
417 v3_lerp( p
[1], temp_alignments
[1], 0.5f
, p
[2] );
419 v3_lerp( p
[1], rn
->co
, 0.5f
, p
[2] );
421 p
[2][3] = rn
->ref_count
;
422 p
[2][3] -= (float)rn
->ref_total
* 0.5f
;
425 v3_copy( end_gate
->co
[0], p
[2] );
426 v3_add( (v3f
){0.0f
,0.1f
,0.0f
}, p
[2], p
[2] );
427 p
[2][3] = collector
->ref_count
;
429 if( i
== route
->checkpoints_count
-1)
432 p
[2][3] -= (float)collector
->route_count
* 0.5f
;
433 //collector->ref_count ++;
436 /* p0,p1,p2 bezier patch is complete
437 * --------------------------------------*/
438 v3f surf0
, surf2
, n0
, n2
;
440 if( bh_closest_point( world
->geo_bh
, p
[0], surf0
, 5.0f
) == -1 )
441 v3_add( (v3f
){0.0f
,-0.1f
,0.0f
}, p
[0], surf0
);
443 if( bh_closest_point( world
->geo_bh
, p
[2], surf2
, 5.0f
) == -1 )
444 v3_add( (v3f
){0.0f
,-0.1f
,0.0f
}, p
[2], surf2
);
446 v3_sub( surf0
, p
[0], n0
);
447 v3_sub( surf2
, p
[2], n2
);
451 world_routes_place_curve( world
, p
, n0
, n2
);
454 v4_copy( p
[2], p
[0] );
458 scene_copy_slice( world
->scene_lines
, &route
->sm
);
462 * Create the strips of colour that run through the world along course paths
464 VG_STATIC
void world_routes_generate( world_instance
*world
)
466 vg_info( "Generating route meshes\n" );
467 world
->scene_lines
= scene_init( world
->heap
, 200000, 300000 );
469 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
470 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
472 gate
->route_count
= 0;
475 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route_node
); i
++ ){
476 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
, i
);
481 for( u32 k
=0; k
<mdl_arrcount(&world
->ent_route
); k
++ ){
482 ent_route
*route
= mdl_arritm( &world
->ent_route
, k
);
484 for( int i
=0; i
<route
->checkpoints_count
; i
++ ){
485 int i0
= route
->checkpoints_start
+i
,
486 i1
= route
->checkpoints_start
+((i
+1)%route
->checkpoints_count
);
488 ent_checkpoint
*c0
= mdl_arritm(&world
->ent_checkpoint
, i0
),
489 *c1
= mdl_arritm(&world
->ent_checkpoint
, i1
);
491 ent_gate
*start_gate
= mdl_arritm( &world
->ent_gate
, c0
->gate_index
);
492 start_gate
= mdl_arritm( &world
->ent_gate
, start_gate
->target
);
493 start_gate
->route_count
++;
495 if( !c0
->path_count
)
498 for( int j
=0; j
<c0
->path_count
; j
++ ){
499 ent_path_index
*index
= mdl_arritm( &world
->ent_path_index
,
501 ent_route_node
*rn
= mdl_arritm( &world
->ent_route_node
,
508 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ )
509 world_routes_create_mesh( world
, i
);
511 vg_acquire_thread_sync();
513 scene_upload( world
->scene_lines
, &world
->mesh_route_lines
);
515 vg_release_thread_sync();
516 vg_linear_del( world
->heap
, world
->scene_lines
);
518 world_routes_clear( world
);
521 /* load all routes from model header */
522 VG_STATIC
void world_routes_ent_init( world_instance
*world
)
524 vg_info( "Initializing routes\n" );
526 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
527 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
528 for( u32 j
=0; j
<4; j
++ ){
529 gate
->routes
[j
] = 0xffff;
533 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
534 ent_route
*route
= mdl_arritm(&world
->ent_route
,i
);
535 mdl_transform_m4x3( &route
->transform
, route
->board_transform
);
537 route
->official_track_id
= 0xffffffff;
538 for( u32 j
=0; j
<vg_list_size(track_infos
); j
++ ){
539 if( !strcmp(track_infos
[j
].name
,
540 mdl_pstr(&world
->meta
,route
->pstr_name
))){
541 route
->official_track_id
= j
;
545 for( u32 j
=0; j
<route
->checkpoints_count
; j
++ ){
546 u32 id
= route
->checkpoints_start
+ j
;
547 ent_checkpoint
*cp
= mdl_arritm(&world
->ent_checkpoint
,id
);
549 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
551 for( u32 k
=0; k
<4; k
++ ){
552 if( gate
->routes
[k
] == 0xffff ){
558 if( gate
->type
== k_gate_type_teleport
){
559 gate
= mdl_arritm(&world
->ent_gate
, gate
->target
);
561 for( u32 k
=0; k
<4; k
++ ){
562 if( gate
->routes
[k
] == i
){
563 vg_error( "already assigned route to gate\n" );
566 if( gate
->routes
[k
] == 0xffff ){
575 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_gate
); i
++ ){
576 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, i
);
579 world_routes_clear( world
);
583 * -----------------------------------------------------------------------------
585 * -----------------------------------------------------------------------------
588 VG_STATIC
void world_routes_init(void)
590 world_global
.current_run_version
= 200;
591 world_global
.time
= 300.0;
592 world_global
.last_use
= 0.0;
594 shader_scene_route_register();
595 shader_routeui_register();
598 VG_STATIC
void world_routes_update( world_instance
*world
)
600 world_global
.time
+= vg
.time_delta
;
602 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
603 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
605 int target
= route
->active_checkpoint
== 0xffff? 0: 1;
606 route
->factive
= vg_lerpf( route
->factive
, target
, 0.6f
*vg
.time_delta
);
609 for( u32 i
=0; i
<world_global
.text_particle_count
; i
++ ){
610 struct text_particle
*particle
= &world_global
.text_particles
[i
];
611 rb_object_debug( &particle
->obj
, VG__RED
);
615 VG_STATIC
void world_routes_fixedupdate( world_instance
*world
)
619 for( u32 i
=0; i
<world_global
.text_particle_count
; i
++ ){
620 struct text_particle
*particle
= &world_global
.text_particles
[i
];
622 if( rb_global_has_space() ){
623 rb_ct
*buf
= rb_global_buffer();
625 int l
= rb_sphere__scene( particle
->obj
.rb
.to_world
,
626 &particle
->obj
.inf
.sphere
,
627 NULL
, &world
->rb_geo
.inf
.scene
, buf
);
629 for( int j
=0; j
<l
; j
++ ){
630 buf
[j
].rba
= &particle
->obj
.rb
;
631 buf
[j
].rbb
= &world
->rb_geo
.rb
;
634 rb_contact_count
+= l
;
638 rb_presolve_contacts( rb_contact_buffer
, rb_contact_count
);
640 for( int i
=0; i
<rb_contact_count
; i
++ ){
641 rb_contact_restitution( rb_contact_buffer
+i
, vg_randf() );
644 for( int i
=0; i
<6; i
++ ){
645 rb_solve_contacts( rb_contact_buffer
, rb_contact_count
);
648 for( u32 i
=0; i
<world_global
.text_particle_count
; i
++ ){
649 struct text_particle
*particle
= &world_global
.text_particles
[i
];
650 rb_iter( &particle
->obj
.rb
);
653 for( u32 i
=0; i
<world_global
.text_particle_count
; i
++ ){
654 struct text_particle
*particle
= &world_global
.text_particles
[i
];
655 rb_update_transform( &particle
->obj
.rb
);
659 VG_STATIC
void bind_terrain_noise(void);
660 VG_STATIC
void world_bind_light_array( world_instance
*world
,
661 GLuint shader
, GLuint location
,
663 VG_STATIC
void world_bind_light_index( world_instance
*world
,
664 GLuint shader
, GLuint location
,
667 VG_STATIC
void world_routes_update_timer_texts( world_instance
*world
)
669 world_global
.timer_text_count
= 0;
671 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
672 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
674 if( route
->active_checkpoint
!= 0xffff ){
675 u32 next
= route
->active_checkpoint
+1;
676 next
= next
% route
->checkpoints_count
;
677 next
+= route
->checkpoints_start
;
679 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, next
);
680 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
681 ent_gate
*dest
= mdl_arritm( &world
->ent_gate
, gate
->target
);
685 if( dest
->routes
[j
] == i
){
695 struct timer_text
*text
=
696 &world_global
.timer_texts
[ world_global
.timer_text_count
++ ];
701 if( route
->valid_checkpoints
>= route
->checkpoints_count
){
702 double lap_time
= world_global
.time
- route
->timing_base
,
703 time_centiseconds
= lap_time
* 100.0;
705 if( time_centiseconds
> (float)0xfffe ) time_centiseconds
= 0.0;
707 u16 centiseconds
= time_centiseconds
,
708 seconds
= centiseconds
/ 100,
709 minutes
= seconds
/ 60;
715 if( minutes
> 9 ) minutes
= 9;
719 highscore_intr( text
->text
, minutes
, 1, ' ' ); j
++;
720 text
->text
[j
++] = ':';
723 if( seconds
>= 10 || minutes
){
724 highscore_intr( text
->text
+j
, seconds
, 2, '0' ); j
+=2;
727 highscore_intr( text
->text
+j
, seconds
, 1, '0' ); j
++;
730 text
->text
[j
++] = '.';
731 highscore_intr( text
->text
+j
, centiseconds
, 1, '0' ); j
++;
732 text
->text
[j
] = '\0';
735 highscore_intr( text
->text
, route
->valid_checkpoints
, 1, ' ' );
737 highscore_intr( text
->text
+2, route
->checkpoints_count
+1, 1, ' ' );
738 text
->text
[3] = '\0';
741 float align_r
= font3d_string_width( &world_global
.font
, 0,
746 { -0.92f
, h0
, depth
},
747 { 0.92f
- align_r
, h0
, depth
},
748 { -0.92f
, h1
, depth
},
749 { 0.92f
- align_r
, h1
, depth
},
752 if( dest
->route_count
== 1 ){
753 positions
[0][0] = -align_r
*0.5f
;
754 positions
[0][1] = h1
;
757 m3x3_copy( gate
->to_world
, text
->transform
);
758 float ratio
= v3_length(text
->transform
[0]) /
759 v3_length(text
->transform
[1]);
761 m3x3_scale( text
->transform
, (v3f
){ size
, size
*ratio
, 0.1f
} );
762 m4x3_mulv( gate
->to_world
, positions
[j
], text
->transform
[3] );
767 VG_STATIC
void world_routes_fracture( world_instance
*world
, ent_gate
*gate
,
768 v3f imp_co
, v3f imp_v
)
770 world_global
.text_particle_count
= 0;
772 for( u32 i
=0; i
<world_global
.timer_text_count
; i
++ ){
773 struct timer_text
*text
= &world_global
.timer_texts
[i
];
775 if( text
->gate
!= gate
) continue;
778 m4x3_mul( gate
->transport
, text
->transform
, transform
);
782 m4x3_decompose( transform
, co
, q
, s
);
788 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
789 v3_muls( text
->route
->colour
, brightness
, colour
);
790 colour
[3] = 1.0f
-text
->route
->factive
;
792 for( u32 j
=0;; j
++ ){
793 char c
= text
->text
[j
];
796 ent_glyph
*glyph
= font3d_glyph( &world_global
.font
, 0, c
);
797 if( !glyph
) continue;
799 if( c
>= (u32
)'0' && c
<= (u32
)'9' && glyph
->indice_count
){
800 struct text_particle
*particle
=
801 &world_global
.text_particles
[world_global
.text_particle_count
++];
803 particle
->glyph
= glyph
;
804 v4_copy( colour
, particle
->colour
);
807 v2_muls( glyph
->size
, 0.5f
, origin
);
812 v3_add( offset
, origin
, world_co
);
813 m4x3_mulv( transform
, world_co
, world_co
);
815 float r
= vg_maxf( s
[0]*glyph
->size
[0], s
[1]*glyph
->size
[1] )*0.5f
;
817 m3x3_identity( particle
->mlocal
);
818 m3x3_scale( particle
->mlocal
, s
);
820 v3_muls( origin
, -1.0f
, particle
->mlocal
[3] );
822 v3_copy( world_co
, particle
->obj
.rb
.co
);
823 v3_muls( imp_v
, 1.0f
+vg_randf(), particle
->obj
.rb
.v
);
824 particle
->obj
.rb
.v
[1] += 2.0f
;
826 v4_copy( q
, particle
->obj
.rb
.q
);
827 particle
->obj
.rb
.w
[0] = vg_randf()*2.0f
-1.0f
;
828 particle
->obj
.rb
.w
[1] = vg_randf()*2.0f
-1.0f
;
829 particle
->obj
.rb
.w
[2] = vg_randf()*2.0f
-1.0f
;
831 particle
->obj
.type
= k_rb_shape_sphere
;
832 particle
->obj
.inf
.sphere
.radius
= r
*0.6f
;
834 rb_init_object( &particle
->obj
);
836 offset
[0] += glyph
->size
[0];
841 VG_STATIC
void render_world_routes( world_instance
*world
, camera
*cam
,
844 m4x3f identity_matrix
;
845 m4x3_identity( identity_matrix
);
847 shader_scene_route_use();
848 shader_scene_route_uTexGarbage(0);
849 world_link_lighting_ub( world
, _shader_scene_route
.id
);
850 world_bind_position_texture( world
, _shader_scene_route
.id
,
851 _uniform_scene_route_g_world_depth
, 2 );
852 world_bind_light_array( world
, _shader_scene_route
.id
,
853 _uniform_scene_route_uLightsArray
, 3 );
854 world_bind_light_index( world
, _shader_scene_route
.id
,
855 _uniform_scene_route_uLightsIndex
, 4 );
856 bind_terrain_noise();
858 shader_scene_route_uPv( cam
->mtx
.pv
);
859 shader_scene_route_uPvmPrev( cam
->mtx_prev
.pv
);
860 shader_scene_route_uMdl( identity_matrix
);
861 shader_scene_route_uCamera( cam
->transform
[3] );
863 mesh_bind( &world
->mesh_route_lines
);
865 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
866 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
869 v3_lerp( (v3f
){0.7f
,0.7f
,0.7f
}, route
->colour
, route
->factive
, colour
);
870 colour
[3] = route
->factive
*0.2f
;
872 shader_scene_route_uColour( colour
);
873 mdl_draw_submesh( &route
->sm
);
877 * ---------------------------------------------------- */
878 if( layer_depth
== 0 ){
879 font3d_bind( &world_global
.font
, cam
);
881 for( u32 i
=0; i
<world_global
.timer_text_count
; i
++ ){
882 struct timer_text
*text
= &world_global
.timer_texts
[i
];
885 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
886 v3_muls( text
->route
->colour
, brightness
, colour
);
887 colour
[3] = 1.0f
-text
->route
->factive
;
889 shader_model_font_uColour( colour
);
890 font3d_simple_draw( &world_global
.font
, 0, text
->text
,
891 cam
, text
->transform
);
894 shader_model_font_uOffset( (v3f
){0.0f
,0.0f
,0.0f
} );
896 for( u32 i
=0; i
<world_global
.text_particle_count
; i
++ ){
897 struct text_particle
*particle
= &world_global
.text_particles
[i
];
901 m4x3_expand( particle
->mdl
, prev_mtx
);
902 m4x4_mul( cam
->mtx_prev
.pv
, prev_mtx
, prev_mtx
);
904 shader_model_font_uPvmPrev( prev_mtx
);
908 rb_extrapolate( &particle
->obj
.rb
, model
[3], q
);
911 m4x3_mul( model
, particle
->mlocal
, particle
->mdl
);
912 shader_model_font_uMdl( particle
->mdl
);
913 shader_model_font_uColour( particle
->colour
);
915 mesh_drawn( particle
->glyph
->indice_start
,
916 particle
->glyph
->indice_count
);
921 * ---------------------------------------------------- */
923 shader_model_gate_use();
924 shader_model_gate_uPv( cam
->mtx
.pv
);
925 shader_model_gate_uCam( cam
->pos
);
926 shader_model_gate_uTime( vg
.time
*0.25f
);
927 shader_model_gate_uInvRes( (v2f
){
928 1.0f
/ (float)vg
.window_x
,
929 1.0f
/ (float)vg
.window_y
});
931 mesh_bind( &world_global
.mesh_gate
);
933 /* skip writing into the motion vectors for this */
934 glDrawBuffers( 1, (GLenum
[]){ GL_COLOR_ATTACHMENT0
} );
936 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_route
); i
++ ){
937 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
939 if( route
->active_checkpoint
!= 0xffff ){
941 float brightness
= 0.3f
+ world
->ub_lighting
.g_day_phase
;
942 v3_muls( route
->colour
, brightness
, colour
);
943 colour
[3] = 1.0f
-route
->factive
;
945 shader_model_gate_uColour( colour
);
947 u32 next
= route
->active_checkpoint
+1+layer_depth
;
948 next
= next
% route
->checkpoints_count
;
949 next
+= route
->checkpoints_start
;
951 ent_checkpoint
*cp
= mdl_arritm( &world
->ent_checkpoint
, next
);
952 ent_gate
*gate
= mdl_arritm( &world
->ent_gate
, cp
->gate_index
);
953 shader_model_gate_uMdl( gate
->to_world
);
955 for( u32 j
=0; j
<4; j
++ ){
956 if( gate
->routes
[j
] == i
){
957 mdl_draw_submesh( &world_global
.sm_gate_marker
[j
] );
963 glDrawBuffers( 2, (GLenum
[]){ GL_COLOR_ATTACHMENT0
, GL_COLOR_ATTACHMENT1
} );
966 #endif /* ROUTES_H */