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
{
60 * -------------------------------------------------------
63 char world_name
[ 64 ];
76 struct ub_world_lighting
{
84 v4f g_nightsky_colour
;
94 float g_shadow_length
;
95 float g_shadow_spread
;
102 int g_shadow_samples
;
105 int g_debug_complexity
;
111 GLuint tbo_light_entities
,
115 float probabilities
[3];
119 struct framebuffer heightmap
;
122 * Dynamically allocated when world_load is called.
124 * the following arrays index somewhere into this linear
128 * --------------------------------------------------------------------------
139 struct world_surface
{
147 mdl_array_ptr ent_spawn
,
160 ent_gate
*rendering_gate
;
163 * ----------------------------------------------------
171 /* spacial mappings */
177 glmesh mesh_route_lines
;
185 VG_STATIC
struct world_global
{
187 * Allocated as system memory
188 * --------------------------------------------------------------------------
195 mdl_submesh sm_gate_surface
,
198 double sky_time
, sky_rate
, sky_target_rate
;
200 u32 current_run_version
;
201 double time
, rewind_from
, rewind_to
, last_use
;
203 /* water rendering */
205 struct framebuffer fbreflect
, fbdepth
;
209 /* split flap display */
211 glmesh mesh_base
, mesh_display
;
213 u32 active_route_board
;
223 int switching_to_new_world
;
225 world_instance worlds
[4];
239 u32 timer_text_count
;
241 struct text_particle
{
250 u32 text_particle_count
;
255 VG_STATIC world_instance
*get_active_world( void )
257 return &world_global
.worlds
[ world_global
.active_world
];
265 int ray_hit_is_ramp( world_instance
*world
, ray_hit
*hit
);
268 struct world_surface
*ray_hit_surface( world_instance
*world
, ray_hit
*hit
);
271 void ray_world_get_tri( world_instance
*world
, ray_hit
*hit
, v3f tri
[3] );
274 int ray_world( world_instance
*world
, v3f pos
, v3f dir
, ray_hit
*hit
);
280 #include "world_routes.h"
281 #include "world_sfd.h"
282 #include "world_render.h"
283 #include "world_water.h"
284 #include "world_volumes.h"
285 #include "world_gen.h"
286 #include "world_gate.h"
289 * -----------------------------------------------------------------------------
291 * -----------------------------------------------------------------------------
294 VG_STATIC
int world_stop_sound( int argc
, const char *argv
[] )
296 world_instance
*world
= get_active_world();
300 VG_STATIC
void world_init(void)
302 world_global
.sky_rate
= 1.0;
303 world_global
.sky_target_rate
= 1.0;
305 shader_scene_standard_register();
306 shader_scene_standard_alphatest_register();
307 shader_scene_vertex_blend_register();
308 shader_scene_terrain_register();
309 shader_scene_depth_register();
310 shader_scene_position_register();
312 shader_model_sky_register();
314 vg_info( "Loading world resources\n" );
316 vg_linear_clear( vg_mem
.scratch
);
319 mdl_open( &msky
, "models/rs_skydome.mdl", vg_mem
.scratch
);
320 mdl_load_metadata_block( &msky
, vg_mem
.scratch
);
321 mdl_load_mesh_block( &msky
, vg_mem
.scratch
);
324 vg_acquire_thread_sync();
326 mdl_unpack_glmesh( &msky
, &world_global
.skydome
);
328 vg_release_thread_sync();
331 vg_info( "Loading other world systems\n" );
333 vg_loader_step( world_render_init
, NULL
);
334 vg_loader_step( world_sfd_init
, NULL
);
335 vg_loader_step( world_water_init
, NULL
);
336 vg_loader_step( world_gates_init
, NULL
);
337 vg_loader_step( world_routes_init
, NULL
);
339 /* Allocate dynamic world memory arena */
340 u32 max_size
= 76*1024*1024;
341 world_global
.generic_heap
= vg_create_linear_allocator( vg_mem
.rtmemory
,
346 typedef struct ent_call ent_call
;
353 VG_STATIC
void entity_call( world_instance
*world
, ent_call
*call
);
355 VG_STATIC
void ent_volume_call( world_instance
*world
, ent_call
*call
)
357 ent_volume
*volume
= mdl_arritm( &world
->ent_volume
, call
->ent
.index
);
358 if( !volume
->target
.type
) return;
360 if( call
->function
== k_ent_function_trigger
){
361 call
->ent
= volume
->target
;
363 if( volume
->type
== k_volume_subtype_particle
){
364 float *co
= alloca( sizeof(float)*3 );
365 co
[0] = vg_randf()*2.0f
-1.0f
;
366 co
[1] = vg_randf()*2.0f
-1.0f
;
367 co
[2] = vg_randf()*2.0f
-1.0f
;
368 m4x3_mulv( volume
->to_world
, co
, co
);
370 call
->function
= k_ent_function_particle_spawn
;
372 entity_call( world
, call
);
375 entity_call( world
, call
);
379 VG_STATIC
void ent_audio_call( world_instance
*world
, ent_call
*call
)
381 ent_audio
*audio
= mdl_arritm( &world
->ent_audio
, call
->ent
.index
);
385 if( call
->function
== k_ent_function_particle_spawn
){
386 v3_copy( call
->data
, sound_co
);
388 else if( call
->function
== k_ent_function_trigger
){
389 v3_copy( audio
->transform
.co
, sound_co
);
392 vg_fatal_exit_loop( "ent_audio_call (invalid function id)" );
394 float chance
= vg_randf()*100.0f
,
397 for( u32 i
=0; i
<audio
->clip_count
; i
++ ){
398 ent_audio_clip
*clip
= mdl_arritm( &world
->ent_audio_clip
,
399 audio
->clip_start
+i
);
401 float mod
= world
->probabilities
[ audio
->probability_curve
],
402 p
= clip
->probability
* mod
;
410 if( audio
->behaviour
== k_channel_behaviour_unlimited
){
411 audio_oneshot_3d( &clip
->clip
, sound_co
,
412 audio
->transform
.s
[0],
415 else if( audio
->behaviour
== k_channel_behaviour_discard_if_full
){
417 audio_get_group_idle_channel( audio
->group
,
418 audio
->max_channels
);
421 audio_channel_init( ch
, &clip
->clip
, audio
->flags
);
422 audio_channel_group( ch
, audio
->group
);
423 audio_channel_set_spacial( ch
, sound_co
, audio
->transform
.s
[0] );
424 audio_channel_edit_volume( ch
, audio
->volume
, 1 );
425 ch
= audio_relinquish_channel( ch
);
428 else if( audio
->behaviour
== k_channel_behaviour_crossfade_if_full
){
430 audio_get_group_idle_channel( audio
->group
,
431 audio
->max_channels
);
435 audio_channel
*existing
=
436 audio_get_group_first_active_channel( audio
->group
);
439 if( existing
->source
== &clip
->clip
){
445 existing
= audio_channel_fadeout(existing
, audio
->crossfade
);
448 ch
= audio_get_first_idle_channel();
452 audio_channel_init( ch
, &clip
->clip
, audio
->flags
);
453 audio_channel_group( ch
, audio
->group
);
454 audio_channel_fadein( ch
, audio
->crossfade
);
455 ch
= audio_relinquish_channel( ch
);
465 VG_STATIC
void entity_call( world_instance
*world
, ent_call
*call
)
467 if( call
->ent
.type
== k_ent_volume
){
468 ent_volume_call( world
, call
);
469 } else if( call
->ent
.type
== k_ent_audio
){
470 ent_audio_call( world
, call
);
474 VG_STATIC
void world_update( world_instance
*world
, v3f pos
)
477 static double g_time
= 0.0;
478 g_time
+= vg
.time_delta
* (1.0/(k_day_length
*60.0));
481 struct ub_world_lighting
*state
= &world
->ub_lighting
;
483 state
->g_time
= g_time
;
484 state
->g_realtime
= vg
.time
;
485 state
->g_debug_indices
= k_debug_light_indices
;
486 state
->g_light_preview
= k_light_preview
;
487 state
->g_debug_complexity
= k_debug_light_complexity
;
489 state
->g_time_of_day
= vg_fractf( g_time
);
490 state
->g_day_phase
= cosf( state
->g_time_of_day
* VG_PIf
* 2.0f
);
491 state
->g_sunset_phase
= cosf( state
->g_time_of_day
* VG_PIf
* 4.0f
+ VG_PIf
);
493 state
->g_day_phase
= state
->g_day_phase
* 0.5f
+ 0.5f
;
494 state
->g_sunset_phase
= powf( state
->g_sunset_phase
* 0.5f
+ 0.5f
, 6.0f
);
496 float a
= state
->g_time_of_day
* VG_PIf
* 2.0f
;
497 state
->g_sun_dir
[0] = sinf( a
);
498 state
->g_sun_dir
[1] = cosf( a
);
499 state
->g_sun_dir
[2] = 0.2f
;
500 v3_normalize( state
->g_sun_dir
);
503 world
->probabilities
[ k_probability_curve_constant
] = 1.0f
;
505 float dp
= state
->g_day_phase
;
507 world
->probabilities
[ k_probability_curve_wildlife_day
] =
508 (dp
*dp
*0.8f
+state
->g_sunset_phase
)*0.8f
;
509 world
->probabilities
[ k_probability_curve_wildlife_night
] =
510 1.0f
-powf(fabsf((state
->g_time_of_day
-0.5f
)*5.0f
),5.0f
);
513 glBindBuffer( GL_UNIFORM_BUFFER
, world
->ubo_lighting
);
514 glBufferSubData( GL_UNIFORM_BUFFER
, 0,
515 sizeof(struct ub_world_lighting
), &world
->ub_lighting
);
518 world_global
.sky_time
+= world_global
.sky_rate
* vg
.time_delta
;
519 world_global
.sky_rate
= vg_lerp( world_global
.sky_rate
,
520 world_global
.sky_target_rate
,
521 vg
.time_delta
* 5.0 );
523 world_routes_update_timer_texts( world
);
524 world_routes_update( world
);
525 //world_routes_debug( world );
527 /* ---- SFD ------------ */
529 if( mdl_arrcount( &world
->ent_route
) ){
531 float min_dist
= INFINITY
;
533 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_route
); i
++ ){
534 ent_route
*route
= mdl_arritm( &world
->ent_route
, i
);
535 float dist
= v3_dist2( route
->board_transform
[3], pos
);
537 if( dist
< min_dist
){
543 if( (world_global
.sfd
.active_route_board
!= closest
)
544 || network_scores_updated
)
546 network_scores_updated
= 0;
547 world_global
.sfd
.active_route_board
= closest
;
549 ent_route
*route
= mdl_arritm( &world
->ent_route
, closest
);
550 u32 id
= route
->official_track_id
;
552 if( id
!= 0xffffffff ){
553 struct netmsg_board
*local_board
=
554 &scoreboard_client_data
.boards
[id
];
556 for( int i
=0; i
<13; i
++ ){
557 sfd_encode( i
, &local_board
->data
[27*i
] );
560 sfd_encode( 0, mdl_pstr( &world
->meta
, route
->pstr_name
) );
561 sfd_encode( 1, "No data" );
569 static float random_accum
= 0.0f
;
570 random_accum
+= vg
.time_delta
;
572 u32 random_ticks
= 0;
574 while( random_accum
> 0.1f
){
575 random_accum
-= 0.1f
;
579 float radius
= 25.0f
;
580 boxf volume_proximity
;
581 v3_add( pos
, (v3f
){ radius
, radius
, radius
}, volume_proximity
[1] );
582 v3_sub( pos
, (v3f
){ radius
, radius
, radius
}, volume_proximity
[0] );
585 bh_iter_init( 0, &it
);
590 while( bh_next( world
->volume_bh
, &it
, volume_proximity
, &idx
) ){
591 ent_volume
*volume
= mdl_arritm( &world
->ent_volume
, idx
);
593 boxf cube
= {{-1.0f
,-1.0f
,-1.0f
},{1.0f
,1.0f
,1.0f
}};
595 if( volume
->type
== k_volume_subtype_trigger
){
597 m4x3_mulv( volume
->to_local
, pos
, local
);
599 if( (fabsf(local
[0]) <= 1.0f
) &&
600 (fabsf(local
[1]) <= 1.0f
) &&
601 (fabsf(local
[2]) <= 1.0f
) )
604 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff00ff00 );
606 if( !world_global
.in_volume
){
608 basecall
.ent
.index
= idx
;
609 basecall
.ent
.type
= k_ent_volume
;
610 basecall
.function
= k_ent_function_trigger
;
611 basecall
.data
= NULL
;
613 entity_call( world
, &basecall
);
617 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff0000ff );
619 else if( volume
->type
== k_volume_subtype_particle
){
620 vg_line_boxf_transformed( volume
->to_world
, cube
, 0xff00c0ff );
622 for( int j
=0; j
<random_ticks
; j
++ ){
624 basecall
.ent
.index
= idx
;
625 basecall
.ent
.type
= k_ent_volume
;
626 basecall
.function
= k_ent_function_trigger
;
627 basecall
.data
= NULL
;
629 entity_call( world
, &basecall
);
633 world_global
.in_volume
= in_volume
;
636 if( k_debug_light_indices
)
638 for( int i
=0; i
<world
->light_count
; i
++ ){
639 struct world_light
*light
= &world
->lights
[i
];
640 struct classtype_world_light
*inf
= light
->inf
;
642 u32 colour
= 0xff000000;
643 u8 r
= inf
->colour
[0] * 255.0f
,
644 g
= inf
->colour
[1] * 255.0f
,
645 b
= inf
->colour
[2] * 255.0f
;
651 vg_line_pt3( light
->node
->co
, 0.25f
, colour
);
659 /* process soundscape transactions */
661 for( int i
=0; i
<world
->soundscape_count
; i
++ )
663 struct soundscape
*s
= &world
->soundscapes
[i
];
666 for( int j
=0; j
<s
->max_instances
; j
++ )
670 if( audio_channel_finished(s
->channels
[j
]) )
671 s
->channels
[j
] = audio_relinquish_channel( s
->channels
[j
] );
682 * -----------------------------------------------------------------------------
684 * -----------------------------------------------------------------------------
687 VG_STATIC
void ray_world_get_tri( world_instance
*world
,
688 ray_hit
*hit
, v3f tri
[3] )
690 for( int i
=0; i
<3; i
++ )
691 v3_copy( world
->scene_geo
->arrvertices
[ hit
->tri
[i
] ].co
, tri
[i
] );
694 VG_STATIC
int ray_world( world_instance
*world
,
695 v3f pos
, v3f dir
, ray_hit
*hit
)
697 return scene_raycast( world
->scene_geo
, world
->geo_bh
, pos
, dir
, hit
);
701 * Cast a sphere from a to b and see what time it hits
703 VG_STATIC
int spherecast_world( world_instance
*world
,
704 v3f pa
, v3f pb
, float r
, float *t
, v3f n
)
707 bh_iter_init( 0, &it
);
710 box_init_inf( region
);
711 box_addpt( region
, pa
);
712 box_addpt( region
, pb
);
714 v3_add( (v3f
){ r
, r
, r
}, region
[1], region
[1] );
715 v3_add( (v3f
){-r
,-r
,-r
}, region
[0], region
[0] );
718 v3_sub( pb
, pa
, dir
);
721 dir_inv
[0] = 1.0f
/dir
[0];
722 dir_inv
[1] = 1.0f
/dir
[1];
723 dir_inv
[2] = 1.0f
/dir
[2];
729 while( bh_next( world
->geo_bh
, &it
, region
, &idx
) ){
730 u32
*ptri
= &world
->scene_geo
->arrindices
[ idx
*3 ];
736 for( int j
=0; j
<3; j
++ ){
737 v3_copy( world
->scene_geo
->arrvertices
[ptri
[j
]].co
, tri
[j
] );
738 box_addpt( box
, tri
[j
] );
741 v3_add( (v3f
){ r
, r
, r
}, box
[1], box
[1] );
742 v3_add( (v3f
){-r
,-r
,-r
}, box
[0], box
[0] );
744 if( !ray_aabb1( box
, pa
, dir_inv
, 1.0f
) )
749 if( spherecast_triangle( tri
, pa
, dir
, r
, &t
, n1
) ){
763 struct world_surface
*world_tri_index_surface( world_instance
*world
,
766 for( int i
=1; i
<world
->surface_count
; i
++ ){
767 struct world_surface
*surf
= &world
->surfaces
[i
];
769 if( (index
>= surf
->sm_geo
.vertex_start
) &&
770 (index
< surf
->sm_geo
.vertex_start
+surf
->sm_geo
.vertex_count
) )
776 return &world
->surfaces
[0];
779 VG_STATIC
struct world_surface
*world_contact_surface( world_instance
*world
,
782 return world_tri_index_surface( world
, ct
->element_id
);
785 VG_STATIC
struct world_surface
*ray_hit_surface( world_instance
*world
,
788 return world_tri_index_surface( world
, hit
->tri
[0] );