2 * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
10 typedef struct world_instance world_instance
;
12 #include "vg/vg_loader.h"
15 #include "network_msg.h"
18 #include "rigidbody.h"
24 #include "shaders/scene_standard.h"
25 #include "shaders/scene_standard_alphatest.h"
26 #include "shaders/scene_vertex_blend.h"
27 #include "shaders/scene_terrain.h"
28 #include "shaders/scene_depth.h"
29 #include "shaders/scene_position.h"
31 #include "shaders/model_sky.h"
33 enum { k_max_ui_segments
= 8 };
35 enum { k_max_ui_elements
= k_max_ui_segments
};
36 enum { k_max_element_verts
= 10 };
37 enum { k_max_element_indices
= 20 };
39 enum { k_route_ui_max_verts
= k_max_ui_elements
*k_max_element_verts
};
40 enum { k_route_ui_max_indices
= k_max_ui_elements
*k_max_element_indices
};
44 k_logic_type_relay
= 1,
45 k_logic_type_chance
= 2,
46 k_logic_type_achievement
= 3
52 k_geo_type_nonsolid
= 1,
56 static const float k_light_cube_size
= 8.0f
;
58 struct world_instance
{
61 * -------------------------------------------------------
66 k_world_status_unloaded
= 0,
67 k_world_status_loading
= 1,
68 k_world_status_loaded
= 2,
69 k_world_status_unloading
= 3 /* dont spawn sounds and stuff */
86 struct ub_world_lighting
{
94 v4f g_nightsky_colour
;
106 float g_shadow_length
;
107 float g_shadow_spread
;
111 float g_sunset_phase
;
114 int g_shadow_samples
;
117 int g_debug_complexity
;
123 GLuint tbo_light_entities
,
127 float probabilities
[3];
130 struct framebuffer heightmap
;
133 * Dynamically allocated when world_load is called.
135 * the following arrays index somewhere into this linear
139 * --------------------------------------------------------------------------
150 struct world_surface
{
159 mdl_array_ptr ent_spawn
,
177 ent_gate
*rendering_gate
;
180 * ----------------------------------------------------
184 scene_context scene_geo
,
188 /* spacial mappings */
194 glmesh mesh_route_lines
;
204 * Allocated as system memory
205 * --------------------------------------------------------------------------
213 mdl_submesh sm_gate_surface
,
216 double sky_time
, sky_rate
, sky_target_rate
;
218 u32 current_run_version
;
219 double time
, rewind_from
, rewind_to
, last_use
;
221 /* water rendering */
223 struct framebuffer fbreflect
, fbdepth
;
227 /* split flap display */
229 glmesh mesh_base
, mesh_display
;
231 u32 active_route_board
;
242 world_instance worlds
[4];
255 u32 timer_text_count
;
257 struct text_particle
{
266 u32 text_particle_count
;
269 VG_STATIC
void entity_call( world_instance
*world
, ent_call
*call
);
271 VG_STATIC world_instance
*get_active_world( void )
273 return &world_global
.worlds
[ world_global
.active_world
];
281 int ray_hit_is_ramp( world_instance
*world
, ray_hit
*hit
);
284 struct world_surface
*ray_hit_surface( world_instance
*world
, ray_hit
*hit
);
287 void ray_world_get_tri( world_instance
*world
, ray_hit
*hit
, v3f tri
[3] );
290 int ray_world( world_instance
*world
, v3f pos
, v3f dir
, ray_hit
*hit
);
293 ent_spawn
*world_find_closest_spawn( world_instance
*world
, v3f position
)
295 ent_spawn
*rp
= NULL
, *r
;
296 float min_dist
= INFINITY
;
298 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_spawn
); i
++ ){
299 r
= mdl_arritm( &world
->ent_spawn
, i
);
300 float d
= v3_dist2( r
->transform
.co
, position
);
309 if( mdl_arrcount(&world
->ent_spawn
) ){
310 vg_warn( "Invalid distances to spawns.. defaulting to first one.\n" );
311 return mdl_arritm( &world
->ent_spawn
, 0 );
314 vg_error( "There are no spawns in the level!\n" );
322 ent_spawn
*world_find_spawn_by_name( world_instance
*world
, const char *name
)
324 ent_spawn
*rp
= NULL
, *r
;
325 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_spawn
); i
++ ){
326 r
= mdl_arritm( &world
->ent_spawn
, i
);
327 if( !strcmp( mdl_pstr(&world
->meta
, r
->pstr_name
), name
) ){
334 vg_warn( "No spawn named '%s'\n", name
);
344 k_day_length
= 30.0f
; /* minutes */
346 VG_STATIC
int k_debug_light_indices
= 0,
347 k_debug_light_complexity
= 0,
350 #include "world_routes.h"
351 #include "world_sfd.h"
352 #include "world_render.h"
353 #include "world_water.h"
354 #include "world_volumes.h"
355 #include "world_gen.h"
356 #include "world_gate.h"
359 * -----------------------------------------------------------------------------
361 * -----------------------------------------------------------------------------
364 VG_STATIC
int world_stop_sound( int argc
, const char *argv
[] )
366 world_instance
*world
= get_active_world();
370 VG_STATIC
void world_init(void)
372 VG_VAR_F32( k_day_length
);
373 VG_VAR_I32( k_debug_light_indices
);
374 VG_VAR_I32( k_debug_light_complexity
);
375 VG_VAR_I32( k_light_preview
);
377 world_global
.sky_rate
= 1.0;
378 world_global
.sky_target_rate
= 1.0;
380 shader_scene_standard_register();
381 shader_scene_standard_alphatest_register();
382 shader_scene_vertex_blend_register();
383 shader_scene_terrain_register();
384 shader_scene_depth_register();
385 shader_scene_position_register();
387 shader_model_sky_register();
389 vg_info( "Loading world resources\n" );
391 vg_linear_clear( vg_mem
.scratch
);
394 mdl_open( &msky
, "models/rs_skydome.mdl", vg_mem
.scratch
);
395 mdl_load_metadata_block( &msky
, vg_mem
.scratch
);
396 mdl_async_load_glmesh( &msky
, &world_global
.skydome
);
400 vg_info( "Loading other world systems\n" );
402 vg_loader_step( world_render_init
, NULL
);
403 vg_loader_step( world_sfd_init
, NULL
);
404 vg_loader_step( world_water_init
, NULL
);
405 vg_loader_step( world_gates_init
, NULL
);
406 vg_loader_step( world_routes_init
, NULL
);
408 /* Allocate dynamic world memory arena */
409 u32 max_size
= 76*1024*1024;
410 world_global
.heap
= vg_create_linear_allocator( vg_mem
.rtmemory
, max_size
,
414 VG_STATIC
void ent_volume_call( world_instance
*world
, ent_call
*call
)
416 u32 index
= mdl_entity_id_id( call
->id
);
417 ent_volume
*volume
= mdl_arritm( &world
->ent_volume
, index
);
418 if( !volume
->target
) return;
420 if( call
->function
== k_ent_function_trigger
){
421 call
->id
= volume
->target
;
423 if( volume
->type
== k_volume_subtype_particle
){
424 float *co
= alloca( sizeof(float)*3 );
425 co
[0] = vg_randf64()*2.0f
-1.0f
;
426 co
[1] = vg_randf64()*2.0f
-1.0f
;
427 co
[2] = vg_randf64()*2.0f
-1.0f
;
428 m4x3_mulv( volume
->to_world
, co
, co
);
430 call
->function
= k_ent_function_particle_spawn
;
432 entity_call( world
, call
);
435 entity_call( world
, call
);
440 VG_STATIC
void ent_audio_call( world_instance
*world
, ent_call
*call
)
442 if( world
->status
== k_world_status_unloading
){
443 vg_warn( "cannot modify audio while unloading world\n" );
447 u8 world_id
= (world
- world_global
.worlds
) + 1;
448 u32 index
= mdl_entity_id_id( call
->id
);
449 ent_audio
*audio
= mdl_arritm( &world
->ent_audio
, index
);
453 if( call
->function
== k_ent_function_particle_spawn
){
454 v3_copy( call
->data
, sound_co
);
456 else if( call
->function
== k_ent_function_trigger
){
457 v3_copy( audio
->transform
.co
, sound_co
);
460 vg_fatal_error( "ent_audio_call (invalid function id)" );
462 float chance
= vg_randf64()*100.0f
,
465 for( u32 i
=0; i
<audio
->clip_count
; i
++ ){
466 ent_audio_clip
*clip
= mdl_arritm( &world
->ent_audio_clip
,
467 audio
->clip_start
+i
);
469 float mod
= world
->probabilities
[ audio
->probability_curve
],
470 p
= clip
->probability
* mod
;
477 if( audio
->behaviour
== k_channel_behaviour_unlimited
){
478 audio_oneshot_3d( &clip
->clip
, sound_co
,
479 audio
->transform
.s
[0],
482 else if( audio
->behaviour
== k_channel_behaviour_discard_if_full
){
484 audio_get_group_idle_channel( audio
->group
,
485 audio
->max_channels
);
488 audio_channel_init( ch
, &clip
->clip
, audio
->flags
);
489 audio_channel_group( ch
, audio
->group
);
490 audio_channel_world( ch
, world_id
);
491 audio_channel_set_spacial( ch
, sound_co
, audio
->transform
.s
[0] );
492 audio_channel_edit_volume( ch
, audio
->volume
, 1 );
493 ch
= audio_relinquish_channel( ch
);
496 else if( audio
->behaviour
== k_channel_behaviour_crossfade_if_full
){
498 audio_get_group_idle_channel( audio
->group
,
499 audio
->max_channels
);
503 audio_channel
*existing
=
504 audio_get_group_first_active_channel( audio
->group
);
507 if( existing
->source
== &clip
->clip
){
513 existing
= audio_channel_fadeout(existing
, audio
->crossfade
);
516 ch
= audio_get_first_idle_channel();
520 audio_channel_init( ch
, &clip
->clip
, audio
->flags
);
521 audio_channel_group( ch
, audio
->group
);
522 audio_channel_world( ch
, world_id
);
523 audio_channel_fadein( ch
, audio
->crossfade
);
524 ch
= audio_relinquish_channel( ch
);
534 /* finds any active playing in world and fades them out, we can only do this
536 VG_STATIC
void world_fadeout_audio( world_instance
*world
)
538 if( world
->status
!= k_world_status_unloading
){
539 vg_fatal_error( "World status must be set to 'unloading', to fadeout"
543 u8 world_id
= (world
- world_global
.worlds
) + 1;
546 for( u32 i
=0; i
<AUDIO_CHANNELS
; i
++ ){
547 audio_channel
*ch
= &vg_audio
.channels
[i
];
549 if( ch
->allocated
&& (ch
->world_id
== world_id
) ){
550 ch
= audio_channel_fadeout( ch
, 1.0f
);
556 VG_STATIC
void world_update( world_instance
*world
, v3f pos
)
558 world_global
.sky_time
+= world_global
.sky_rate
* vg
.time_delta
;
559 world_global
.sky_rate
= vg_lerp( world_global
.sky_rate
,
560 world_global
.sky_target_rate
,
561 vg
.time_delta
* 5.0 );
563 world_routes_update_timer_texts( world
);
564 world_routes_update( world
);
565 //world_routes_debug( world );
567 /* ---- traffic -------- */
569 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_traffic
); i
++ ){
570 ent_traffic
*traffic
= mdl_arritm( &world
->ent_traffic
, i
);
572 u32 i1
= traffic
->index
,
576 if( i1
== 0 ) i0
= traffic
->node_count
-1;
579 if( i2
>= traffic
->node_count
) i2
= 0;
581 i0
+= traffic
->start_node
;
582 i1
+= traffic
->start_node
;
583 i2
+= traffic
->start_node
;
587 ent_route_node
*rn0
= mdl_arritm( &world
->ent_route_node
, i0
),
588 *rn1
= mdl_arritm( &world
->ent_route_node
, i1
),
589 *rn2
= mdl_arritm( &world
->ent_route_node
, i2
);
591 v3_copy( rn1
->co
, h
[1] );
592 v3_lerp( rn0
->co
, rn1
->co
, 0.5f
, h
[0] );
593 v3_lerp( rn1
->co
, rn2
->co
, 0.5f
, h
[2] );
595 float const k_sample_dist
= 0.0025f
;
597 eval_bezier3( h
[0], h
[1], h
[2], traffic
->t
, pc
);
598 eval_bezier3( h
[0], h
[1], h
[2], traffic
->t
+k_sample_dist
, pd
);
601 v3_sub( pd
, pc
, v0
);
602 float length
= vg_maxf( 0.0001f
, v3_length( v0
) );
603 v3_muls( v0
, 1.0f
/length
, v0
);
605 float mod
= k_sample_dist
/ length
;
607 traffic
->t
+= traffic
->speed
* vg
.time_delta
* mod
;
609 if( traffic
->t
> 1.0f
){
612 if( traffic
->t
> 1.0f
) traffic
->t
= 0.0f
;
616 if( traffic
->index
>= traffic
->node_count
)
620 v3_copy( pc
, traffic
->transform
.co
);
622 float a
= atan2f( -v0
[0], v0
[2] );
623 q_axis_angle( traffic
->transform
.q
, (v3f
){0.0f
,1.0f
,0.0f
}, -a
);
625 vg_line_pt3( traffic
->transform
.co
, 0.3f
, VG__BLUE
);
628 /* ---- SFD ------------ */
630 if( mdl_arrcount( &world
->ent_route
) ){
632 float min_dist
= INFINITY
;
634 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_route
); i
++ ){
635 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
636 float dist
= v3_dist2( route
->board_transform
[3], pos
);
638 if( dist
< min_dist
){
644 if( (world_global
.sfd
.active_route_board
!= closest
)
645 || network_scores_updated
)
647 network_scores_updated
= 0;
648 world_global
.sfd
.active_route_board
= closest
;
650 ent_route
*route
= mdl_arritm( &world
->ent_route
, closest
);
651 u32 id
= route
->official_track_id
;
653 if( id
!= 0xffffffff ){
654 struct netmsg_board
*local_board
=
655 &scoreboard_client_data
.boards
[id
];
657 for( int i
=0; i
<13; i
++ ){
658 sfd_encode( i
, &local_board
->data
[27*i
] );
661 sfd_encode( 0, mdl_pstr( &world
->meta
, route
->pstr_name
) );
662 sfd_encode( 1, "No data" );
668 static float random_accum
= 0.0f
;
669 random_accum
+= vg
.time_delta
;
671 u32 random_ticks
= 0;
673 while( random_accum
> 0.1f
){
674 random_accum
-= 0.1f
;
678 float radius
= 25.0f
;
679 boxf volume_proximity
;
680 v3_add( pos
, (v3f
){ radius
, radius
, radius
}, volume_proximity
[1] );
681 v3_sub( pos
, (v3f
){ radius
, radius
, radius
}, volume_proximity
[0] );
684 bh_iter_init_box( 0, &it
, volume_proximity
);
689 while( bh_next( world
->volume_bh
, &it
, &idx
) ){
690 ent_volume
*volume
= mdl_arritm( &world
->ent_volume
, idx
);
692 boxf cube
= {{-1.0f
,-1.0f
,-1.0f
},{1.0f
,1.0f
,1.0f
}};
694 if( volume
->type
== k_volume_subtype_trigger
){
696 m4x3_mulv( volume
->to_local
, pos
, local
);
698 if( (fabsf(local
[0]) <= 1.0f
) &&
699 (fabsf(local
[1]) <= 1.0f
) &&
700 (fabsf(local
[2]) <= 1.0f
) )
703 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff00ff00 );
705 if( !world_global
.in_volume
){
707 basecall
.function
= k_ent_function_trigger
;
708 basecall
.id
= mdl_entity_id( k_ent_volume
, idx
);
709 basecall
.data
= NULL
;
711 entity_call( world
, &basecall
);
715 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff0000ff );
717 else if( volume
->type
== k_volume_subtype_particle
){
718 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff00c0ff );
720 for( int j
=0; j
<random_ticks
; j
++ ){
722 basecall
.id
= mdl_entity_id( k_ent_volume
, idx
);
723 basecall
.data
= NULL
;
725 entity_call( world
, &basecall
);
729 world_global
.in_volume
= in_volume
;
732 if( k_debug_light_indices
)
734 for( int i
=0; i
<world
->light_count
; i
++ ){
735 struct world_light
*light
= &world
->lights
[i
];
736 struct classtype_world_light
*inf
= light
->inf
;
738 u32 colour
= 0xff000000;
739 u8 r
= inf
->colour
[0] * 255.0f
,
740 g
= inf
->colour
[1] * 255.0f
,
741 b
= inf
->colour
[2] * 255.0f
;
747 vg_line_pt3( light
->node
->co
, 0.25f
, colour
);
755 * -----------------------------------------------------------------------------
757 * -----------------------------------------------------------------------------
760 VG_STATIC
void ray_world_get_tri( world_instance
*world
,
761 ray_hit
*hit
, v3f tri
[3] )
763 for( int i
=0; i
<3; i
++ )
764 v3_copy( world
->scene_geo
.arrvertices
[ hit
->tri
[i
] ].co
, tri
[i
] );
767 VG_STATIC
int ray_world( world_instance
*world
,
768 v3f pos
, v3f dir
, ray_hit
*hit
)
770 return scene_raycast( &world
->scene_geo
, world
->geo_bh
, pos
, dir
, hit
);
774 * Cast a sphere from a to b and see what time it hits
776 VG_STATIC
int spherecast_world( world_instance
*world
,
777 v3f pa
, v3f pb
, float r
, float *t
, v3f n
)
780 box_init_inf( region
);
781 box_addpt( region
, pa
);
782 box_addpt( region
, pb
);
784 v3_add( (v3f
){ r
, r
, r
}, region
[1], region
[1] );
785 v3_add( (v3f
){-r
,-r
,-r
}, region
[0], region
[0] );
788 v3_sub( pb
, pa
, dir
);
791 dir_inv
[0] = 1.0f
/dir
[0];
792 dir_inv
[1] = 1.0f
/dir
[1];
793 dir_inv
[2] = 1.0f
/dir
[2];
799 bh_iter_init_box( 0, &it
, region
);
801 while( bh_next( world
->geo_bh
, &it
, &idx
) ){
802 u32
*ptri
= &world
->scene_geo
.arrindices
[ idx
*3 ];
808 for( int j
=0; j
<3; j
++ ){
809 v3_copy( world
->scene_geo
.arrvertices
[ptri
[j
]].co
, tri
[j
] );
810 box_addpt( box
, tri
[j
] );
813 v3_add( (v3f
){ r
, r
, r
}, box
[1], box
[1] );
814 v3_add( (v3f
){-r
,-r
,-r
}, box
[0], box
[0] );
816 if( !ray_aabb1( box
, pa
, dir_inv
, 1.0f
) )
821 if( spherecast_triangle( tri
, pa
, dir
, r
, &t
, n1
) ){
835 struct world_surface
*world_tri_index_surface( world_instance
*world
,
838 for( int i
=1; i
<world
->surface_count
; i
++ ){
839 struct world_surface
*surf
= &world
->surfaces
[i
];
841 if( (index
>= surf
->sm_geo
.vertex_start
) &&
842 (index
< surf
->sm_geo
.vertex_start
+surf
->sm_geo
.vertex_count
) )
848 return &world
->surfaces
[0];
851 VG_STATIC
struct world_surface
*world_contact_surface( world_instance
*world
,
854 return world_tri_index_surface( world
, ct
->element_id
);
857 VG_STATIC
struct world_surface
*ray_hit_surface( world_instance
*world
,
860 return world_tri_index_surface( world
, hit
->tri
[0] );
864 * -----------------------------------------------------------------------------
866 * -----------------------------------------------------------------------------
870 enum audio_sprite_type
world_audio_sample_sprite_kandom(v3f origin
, v3f output
);
871 VG_STATIC
void world_audio_sample_distances( v3f co
, int *index
, float *value
);
876 * Trace out a random point, near the player to try and determine water areas
879 enum audio_sprite_type
world_audio_sample_sprite_random(v3f origin
, v3f output
)
881 v3f chance
= { (vg_randf64()-0.5f
) * 30.0f
,
883 (vg_randf64()-0.5f
) * 30.0f
};
886 v3_add( chance
, origin
, pos
);
889 contact
.dist
= vg_minf( 16.0f
, pos
[1] );
891 world_instance
*world
= get_active_world();
893 if( ray_world( world
, pos
, (v3f
){0.0f
,-1.0f
,0.0f
}, &contact
) ){
894 struct world_surface
*mat
= ray_hit_surface( world
, &contact
);
896 if( mat
->info
.surface_prop
== k_surface_prop_grass
){
897 v3_copy( contact
.pos
, output
);
898 return k_audio_sprite_type_grass
;
901 return k_audio_sprite_type_none
;
909 float dist
= fabsf(output
[1] - origin
[1]);
911 if( world
->water
.enabled
&& dist
<=40.0f
)
912 return k_audio_sprite_type_water
;
914 return k_audio_sprite_type_none
;
917 VG_STATIC
void world_audio_sample_distances( v3f co
, int *index
, float *value
)
919 float inr3
= 0.57735027,
920 inr2
= 0.70710678118;
922 v3f sample_directions
[] = {
923 { -1.0f
, 0.0f
, 0.0f
},
924 { 1.0f
, 0.0f
, 0.0f
},
925 { 0.0f
, 0.0f
, 1.0f
},
926 { 0.0f
, 0.0f
, -1.0f
},
927 { 0.0f
, 1.0f
, 0.0f
},
928 { 0.0f
, -1.0f
, 0.0f
},
929 { -inr3
, inr3
, inr3
},
930 { inr3
, inr3
, inr3
},
931 { -inr3
, inr3
, -inr3
},
932 { inr3
, inr3
, -inr3
},
933 { -inr2
, 0.0f
, inr2
},
934 { inr2
, 0.0f
, inr2
},
935 { -inr2
, 0.0f
, -inr2
},
936 { inr2
, 0.0f
, -inr2
},
940 static float distances
[16];
946 v3_copy( sample_directions
[ si
], rd
);
947 v3_add( co
, (v3f
){0.0f
,1.5f
,0.0f
}, ro
);
952 for( int i
=0; i
<10; i
++ ){
953 if( ray_world( get_active_world(), rc
, rd
, &ray
) ){
954 dist
= (float)i
*5.0f
+ ray
.dist
;
958 v3_muladds( rc
, rd
, ray
.dist
, rc
);
962 distances
[si
] = dist
;
965 for( int i
=0; i
<14; i
++ ){
966 if( distances
[i
] != 200.0f
){
967 u32 colours
[] = { VG__RED
, VG__BLUE
, VG__GREEN
,
968 VG__CYAN
, VG__YELOW
, VG__PINK
,
971 u32 colour
= colours
[i
%7];
974 v3_muladds( ro
, sample_directions
[i
], distances
[i
], p1
);
975 vg_line( ro
, p1
, colour
);
976 vg_line_pt3( p1
, 0.1f
, colour
);