1 #include "world_load.h"
2 #include "world_routes.h"
3 #include "world_gate.h"
4 #include "ent_skateshop.h"
9 #include "player_remote.h"
10 #include "vg/vg_loader.h"
15 * load the .mdl file located in path as a world instance
17 static void world_instance_load_mdl( u32 instance_id
, const char *path
){
18 world_instance
*world
= &world_static
.instances
[ instance_id
];
19 world_init_blank( world
);
20 world
->status
= k_world_status_loading
;
22 vg_info( "Loading instance[%u]: %s\n", instance_id
, path
);
24 void *allocator
= NULL
;
25 if( instance_id
== 0 ) allocator
= world_static
.heap
;
26 else allocator
= world_static
.instances
[instance_id
-1].heap
;
28 u32 heap_availible
= vg_linear_remaining( allocator
);
29 u32 min_overhead
= sizeof(vg_linear_allocator
);
31 if( heap_availible
< (min_overhead
+1024) ){
32 vg_fatal_error( "out of memory" );
35 u32 size
= heap_availible
- min_overhead
;
36 void *heap
= vg_create_linear_allocator( allocator
, size
, VG_MEMORY_SYSTEM
);
39 mdl_context
*meta
= &world
->meta
;
41 mdl_open( meta
, path
, world
->heap
);
42 mdl_load_metadata_block( meta
, world
->heap
);
43 mdl_load_animation_block( meta
, world
->heap
);
44 mdl_load_mesh_block( meta
, world
->heap
);
46 vg_info( "%u\n", sizeof(ent_cubemap
) );
48 MDL_LOAD_ARRAY( meta
, &world
->ent_gate
, ent_gate
, heap
);
49 MDL_LOAD_ARRAY( meta
, &world
->ent_camera
, ent_camera
, heap
);
50 MDL_LOAD_ARRAY( meta
, &world
->ent_spawn
, ent_spawn
, heap
);
51 MDL_LOAD_ARRAY( meta
, &world
->ent_light
, ent_light
, heap
);
52 MDL_LOAD_ARRAY( meta
, &world
->ent_route_node
,ent_route_node
, heap
);
53 MDL_LOAD_ARRAY( meta
, &world
->ent_path_index
,ent_path_index
, heap
);
54 MDL_LOAD_ARRAY( meta
, &world
->ent_checkpoint
,ent_checkpoint
, heap
);
55 MDL_LOAD_ARRAY( meta
, &world
->ent_route
, ent_route
, heap
);
56 MDL_LOAD_ARRAY( meta
, &world
->ent_water
, ent_water
, heap
);
57 MDL_LOAD_ARRAY( meta
, &world
->ent_audio_clip
,ent_audio_clip
, heap
);
58 MDL_LOAD_ARRAY( meta
, &world
->ent_audio
, ent_audio
, heap
);
59 MDL_LOAD_ARRAY( meta
, &world
->ent_volume
, ent_volume
, heap
);
60 MDL_LOAD_ARRAY( meta
, &world
->ent_traffic
, ent_traffic
, heap
);
61 MDL_LOAD_ARRAY( meta
, &world
->ent_marker
, ent_marker
, heap
);
62 MDL_LOAD_ARRAY( meta
, &world
->ent_skateshop
, ent_skateshop
, heap
);
63 MDL_LOAD_ARRAY( meta
, &world
->ent_swspreview
,ent_swspreview
, heap
);
64 MDL_LOAD_ARRAY( meta
, &world
->ent_ccmd
, ent_ccmd
, heap
);
65 MDL_LOAD_ARRAY( meta
, &world
->ent_objective
, ent_objective
, heap
);
66 MDL_LOAD_ARRAY( meta
, &world
->ent_challenge
, ent_challenge
, heap
);
67 MDL_LOAD_ARRAY( meta
, &world
->ent_relay
, ent_relay
, heap
);
68 MDL_LOAD_ARRAY( meta
, &world
->ent_cubemap
, ent_cubemap
, heap
);
69 MDL_LOAD_ARRAY( meta
, &world
->ent_miniworld
, ent_miniworld
, heap
);
70 MDL_LOAD_ARRAY( meta
, &world
->ent_prop
, ent_prop
, heap
);
71 MDL_LOAD_ARRAY( meta
, &world
->ent_region
, ent_region
, heap
);
72 MDL_LOAD_ARRAY( meta
, &world
->ent_glider
, ent_glider
, heap
);
73 MDL_LOAD_ARRAY( meta
, &world
->ent_npc
, ent_npc
, heap
);
76 MDL_LOAD_ARRAY( meta
, &infos
, ent_worldinfo
, vg_mem
.scratch
);
78 world
->skybox
= k_skybox_default
;
79 if( mdl_arrcount(&infos
) )
81 world
->info
= *((ent_worldinfo
*)mdl_arritm(&infos
,0));
83 if( world
->meta
.info
.version
>= 104 )
85 if( MDL_CONST_PSTREQ( &world
->meta
, world
->info
.pstr_skybox
,"space"))
87 world
->skybox
= k_skybox_space
;
93 world
->info
.pstr_author
= 0;
94 world
->info
.pstr_desc
= 0;
95 world
->info
.pstr_name
= 0;
96 world
->info
.timezone
= 0.0f
;
97 world
->info
.flags
= 0;
100 time_t seconds
= time(NULL
) % ((u32
)vg_maxf(1.0f
,k_day_length
)*60);
101 world
->time
= ((f64
)(seconds
)/(k_day_length
*60.0));
102 world
->time
+= (world
->info
.timezone
/24.0);
104 /* process resources from pack */
105 u64 t4
= SDL_GetPerformanceCounter();
106 world_gen_load_surfaces( world
);
107 u64 t5
= SDL_GetPerformanceCounter();
108 world_gen_routes_ent_init( world
);
109 world_gen_entities_init( world
);
110 u64 t6
= SDL_GetPerformanceCounter();
113 u64 t0
= SDL_GetPerformanceCounter();
114 world_gen_generate_meshes( world
);
115 u64 t1
= SDL_GetPerformanceCounter();
116 world_gen_routes_generate( instance_id
);
117 u64 t2
= SDL_GetPerformanceCounter();
118 world_gen_compute_light_indices( world
);
119 u64 t3
= SDL_GetPerformanceCounter();
122 u64 utime_mesh
= t1
-t0
,
124 utime_indices
= t3
-t2
,
127 ufreq
= SDL_GetPerformanceFrequency();
129 f64 ftime_mesh
= ((f64
)utime_mesh
/ (f64
)ufreq
)*1000.0,
130 ftime_route
= ((f64
)utime_route
/ (f64
)ufreq
)*1000.0,
131 ftime_ind
= ((f64
)utime_route
/ (f64
)ufreq
)*1000.0,
132 ftime_tex
= ((f64
)utime_tex
/ (f64
)ufreq
)*1000.0,
133 ftime_ent
= ((f64
)utime_ent
/ (f64
)ufreq
)*1000.0;
135 vg_info( "wtime:mesh %.2fms route %.2fms ind %.2fms tex %.2fms ent %.2fms\n",
136 ftime_mesh
, ftime_route
, ftime_ind
, ftime_tex
, ftime_ent
);
138 /* init player position.
139 * - this is overriden by the save state when(if) it loads */
140 world_default_spawn_pos( world
, world
->player_co
);
142 /* allocate leaderboard buffers */
143 u32 bs
= mdl_arrcount(&world
->ent_route
)*sizeof(struct leaderboard_cache
);
144 world
->leaderboard_cache
= vg_linear_alloc( heap
, bs
);
146 for( u32 i
=0; i
<mdl_arrcount( &world
->ent_route
); i
++ )
148 struct leaderboard_cache
*board
= &world
->leaderboard_cache
[i
];
149 board
->data
= vg_linear_alloc( heap
, NETWORK_REQUEST_MAX
);
150 board
->status
= k_request_status_client_error
;
151 board
->cache_time
= 0.0;
155 world
->routes_ui
= vg_linear_alloc( heap
,
156 sizeof(struct route_ui
)*mdl_arrcount(&world
->ent_route
) );
158 vg_async_call( async_world_postprocess
, world
, 0 );
162 struct world_load_complete_data
{
164 enum world_purpose purpose
;
167 static void skaterift_world_load_done( void *payload
, u32 size
)
169 struct world_load_complete_data
*data
= payload
;
170 world_instance
*world
= &world_static
.instances
[ data
->purpose
];
173 vg_msg_init( &sav
, data
->save
.buf
, data
->save
.len
);
175 if( data
->purpose
!= k_world_purpose_hub
)
177 vg_msg player_frame
= sav
;
178 if( vg_msg_seekframe( &player_frame
, "player" ) )
180 vg_msg_getkvvecf( &player_frame
, "position", k_vg_msg_v3f
,
181 world
->player_co
, NULL
);
185 world_entity_start( world
, &sav
);
186 world
->status
= k_world_status_loaded
;
187 world_static
.load_state
= k_world_loader_none
;
189 if( world_static
.clear_async_op_when_done
)
191 skaterift
.op
= k_async_op_none
;
192 world_static
.clear_async_op_when_done
= 0;
197 * Does a complete world switch using the remaining free slots
199 void skaterift_world_load_thread( void *_args
)
201 struct world_load_args args
= *((struct world_load_args
*)_args
);
203 addon_reg
*reg
= args
.reg
;
204 world_static
.instance_addons
[ args
.purpose
] = reg
;
206 char uid
[ADDON_UID_MAX
];
207 addon_alias_uid( ®
->alias
, uid
);
208 vg_info( "LOAD WORLD %s @%d\n", uid
, args
.purpose
);
212 vg_strnull( &path
, path_buf
, 4096 );
214 addon_get_content_folder( reg
, &path
, 1 );
216 vg_str folder
= path
;
217 if( !vg_strgood( &folder
) ) {
218 vg_error( "Load target too long\n" );
222 char worlds
[k_world_max
-1][4096];
226 if( !vg_dir_open(&dir
, folder
.buffer
) ){
227 vg_error( "opendir('%s') failed\n", folder
.buffer
);
231 while( vg_dir_next_entry(&dir
) ){
232 if( vg_dir_entry_type(&dir
) == k_vg_entry_type_file
){
233 const char *d_name
= vg_dir_entry_name(&dir
);
234 if( d_name
[0] == '.' ) continue;
236 vg_str file
= folder
;
237 vg_strcat( &file
, "/" );
238 vg_strcat( &file
, d_name
);
239 if( !vg_strgood( &file
) ) continue;
241 char *ext
= vg_strch( &file
, '.' );
243 if( strcmp(ext
,".mdl") ) continue;
245 if( i
== k_world_max
-1 ){
246 vg_warn( "There are too many .mdl files in the map folder!(3)\n" );
250 strcpy( worlds
[i
++], file
.buffer
);
256 vg_warn( "There are no .mdl files in the map folder.\n" );
260 for( u32 j
=0; j
<i
; j
++ ){
261 vg_str name
= { .buffer
= worlds
[j
], .i
=strlen(worlds
[j
]),
263 char *fname
= vg_strch( &name
, '/' );
265 if( !strcmp( fname
+1, "main.mdl" ) ){
271 world_instance_load_mdl( args
.purpose
, worlds
[first_index
] );
273 vg_async_item
*final_call
=
274 vg_async_alloc( sizeof(struct world_load_complete_data
) );
276 struct world_load_complete_data
*data
= final_call
->payload
;
277 data
->purpose
= args
.purpose
;
279 skaterift_world_get_save_path( args
.purpose
, data
->save
.path
);
280 savedata_file_read( &data
->save
);
282 vg_async_dispatch( final_call
, skaterift_world_load_done
);
286 void skaterift_change_client_world_preupdate(void)
288 if( world_static
.load_state
!= k_world_loader_preload
)
291 /* holding pattern before we can start loading the new world, since we might
292 * be waiting for audio to stop */
293 for( u32 i
=1; i
<k_world_max
; i
++ )
295 world_instance
*inst
= &world_static
.instances
[i
];
297 if( inst
->status
== k_world_status_unloading
)
299 if( world_freeable( inst
) )
307 if( vg_loader_availible() )
309 vg_info( "worlds cleared, begining load\n" );
310 world_static
.load_state
= k_world_loader_load
;
312 vg_linear_clear( vg_async
.buffer
);
313 struct world_load_args
*args
=
314 vg_linear_alloc( vg_async
.buffer
, sizeof(struct world_load_args
) );
315 args
->purpose
= k_world_purpose_client
;
316 args
->reg
= world_static
.instance_addons
[ k_world_purpose_client
];
318 /* this is replaces the already correct reg but we have to set it again
321 /* finally can start the loader */
322 vg_loader_start( skaterift_world_load_thread
, args
);
327 * places all loaded worlds into unloading state, pass NULL to reload the world
329 void skaterift_change_world_start( addon_reg
*reg
)
331 if( world_static
.instance_addons
[ k_world_purpose_client
] == reg
)
333 vg_warn( "World is already loaded\n" );
339 if( world_static
.instance_addons
[ k_world_purpose_client
] )
341 reg
= world_static
.instance_addons
[ k_world_purpose_client
];
342 world_static
.clear_async_op_when_done
= 1;
346 vg_warn( "No client world loaded\n" );
351 world_static
.load_state
= k_world_loader_preload
;
353 if( world_static
.active_instance
!= 0 )
354 skaterift
.op
= k_async_op_clientloading
;
357 addon_alias_uid( ®
->alias
, buf
);
358 vg_info( "switching to: %s\n", buf
);
359 skaterift_autosave(1);
361 vg_linear_clear( vg_mem
.scratch
); /* ?? */
362 vg_info( "unloading old worlds\n" );
364 world_instance
*client_world
=
365 &world_static
.instances
[ k_world_purpose_client
];
367 if( client_world
->status
== k_world_status_loaded
)
369 client_world
->status
= k_world_status_unloading
;
370 world_fadeout_audio( client_world
);
373 world_static
.instance_addons
[ k_world_purpose_client
] = reg
;
374 network_send_item( k_netmsg_playeritem_world1
);
375 relink_all_remote_player_worlds();
376 world_unlink_nonlocal( &world_static
.instances
[k_world_purpose_hub
] );
379 /* console command for the above function */
380 int skaterift_load_world_command( int argc
, const char *argv
[] )
382 if( !vg_loader_availible() )
384 vg_error( "Loading thread is currently unavailible\n" );
390 if( !strcmp( argv
[0], "reload" ) )
392 skaterift_change_world_start( NULL
);
397 addon_uid_to_alias( argv
[0], &q
);
399 u32 reg_id
= addon_match( &q
);
400 if( reg_id
!= 0xffffffff )
402 addon_reg
*reg
= get_addon_from_index( k_addon_type_world
, reg_id
, 0 );
403 skaterift_change_world_start( reg
);
407 vg_error( "Addon '%s' is not installed or not found.\n", argv
[0] );
412 vg_info( "worlds availible to load:\n" );
414 for( int i
=0; i
<addon_count(k_addon_type_world
,0); i
++ )
416 addon_reg
*w
= get_addon_from_index( k_addon_type_world
, i
, 0);
418 char buf
[ADDON_UID_MAX
];
419 addon_alias_uid( &w
->alias
, buf
);
421 if( w
->flags
& ADDON_REG_HIDDEN
)
422 vg_info( " %s [hidden]\n", buf
);
424 vg_info( " %s\n", buf
);
433 * 1. to see if all audios owned by the world have been stopped
434 * 2. that this is the least significant world
436 int world_freeable( world_instance
*world
)
438 if( world
->status
!= k_world_status_unloading
) return 0;
439 u8 world_id
= (world
- world_static
.instances
) + 1;
441 for( u32 i
=world_id
; i
<vg_list_size(world_static
.instances
); i
++ ){
442 if( world_static
.instances
[i
].status
!= k_world_status_unloaded
){
449 for( u32 i
=0; i
<AUDIO_CHANNELS
; i
++ ){
450 audio_channel
*ch
= &vg_audio
.channels
[i
];
452 if( ch
->allocated
&& (ch
->world_id
== world_id
)){
453 if( !audio_channel_finished( ch
) ){
464 * Free all resources for world instance
466 void world_free( world_instance
*world
)
468 vg_info( "Free world @%p\n", world
);
471 mesh_free( &world
->mesh_route_lines
);
472 mesh_free( &world
->mesh_geo
);
473 mesh_free( &world
->mesh_no_collide
);
474 mesh_free( &world
->mesh_water
);
476 /* glDeleteBuffers silently ignores 0's and names that do not correspond to
477 * existing buffer objects.
479 glDeleteBuffers( 1, &world
->tbo_light_entities
);
480 glDeleteTextures( 1, &world
->tex_light_entities
);
481 glDeleteTextures( 1, &world
->tex_light_cubes
);
483 /* delete textures and meshes */
484 glDeleteTextures( world
->texture_count
-1, world
->textures
+1 );
486 u32 world_index
= world
- world_static
.instances
;
488 vg_linear_del( world_static
.instances
[world_index
-1].heap
,
489 vg_linear_header(world
->heap
) );
492 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_cubemap
); i
++ ){
493 ent_cubemap
*cm
= mdl_arritm(&world
->ent_cubemap
,i
);
494 glDeleteTextures( 1, &cm
->texture_id
);
495 glDeleteFramebuffers( 1, &cm
->framebuffer_id
);
496 glDeleteRenderbuffers( 1, &cm
->renderbuffer_id
);
499 world
->status
= k_world_status_unloaded
;
503 * reset the world structure without deallocating persistent buffers
504 * TODO: Make this a memset(0), and have persistent items live in a static loc
506 void world_init_blank( world_instance
*world
)
508 memset( &world
->meta
, 0, sizeof(mdl_context
) );
510 world
->textures
= NULL
;
511 world
->texture_count
= 0;
512 world
->surfaces
= NULL
;
513 world
->surface_count
= 0;
515 world
->geo_bh
= NULL
;
516 world
->entity_bh
= NULL
;
517 world
->entity_list
= NULL
;
518 world
->rendering_gate
= NULL
;
520 world
->water
.enabled
= 0;
523 /* default lighting conditions
524 * -------------------------------------------------------------*/
525 struct ub_world_lighting
*state
= &world
->ub_lighting
;
527 state
->g_light_preview
= 0;
528 state
->g_shadow_samples
= 8;
529 state
->g_water_fog
= 0.04f
;
531 v4_zero( state
->g_water_plane
);
532 v4_zero( state
->g_depth_bounds
);
534 state
->g_shadow_length
= 9.50f
;
535 state
->g_shadow_spread
= 0.65f
;
539 v3_copy( (v3f
){0.37f
, 0.54f
, 0.97f
}, state
->g_daysky_colour
);
540 v3_copy( (v3f
){0.03f
, 0.05f
, 0.20f
}, state
->g_nightsky_colour
);
541 v3_copy( (v3f
){1.00f
, 0.32f
, 0.01f
}, state
->g_sunset_colour
);
542 v3_copy( (v3f
){0.13f
, 0.17f
, 0.35f
}, state
->g_ambient_colour
);
543 v3_copy( (v3f
){0.25f
, 0.17f
, 0.51f
}, state
->g_sunset_ambient
);
544 v3_copy( (v3f
){1.10f
, 0.89f
, 0.35f
}, state
->g_sun_colour
);
547 v3_copy( (v3f
){0.308f
, 0.543f
, 0.904f
}, state
->g_daysky_colour
);
548 v3_copy( (v3f
){0.030f
, 0.050f
, 0.200f
}, state
->g_nightsky_colour
);
549 v3_copy( (v3f
){1.000f
, 0.320f
, 0.010f
}, state
->g_sunset_colour
);
550 v3_copy( (v3f
){0.130f
, 0.170f
, 0.350f
}, state
->g_ambient_colour
);
551 v3_copy( (v3f
){0.25f
, 0.17f
, 0.51f
}, state
->g_sunset_ambient
);
552 v3_copy( (v3f
){1.000f
, 0.809f
, 0.318f
}, state
->g_sun_colour
);