4 #include "world_load.h"
5 #include "world_routes.h"
6 #include "world_gate.h"
7 #include "ent_skateshop.h"
10 #include "vg/vg_msg.h"
14 * load the .mdl file located in path as a world instance
16 static void world_instance_load_mdl( u32 instance_id
, const char *path
){
19 world_instance
*world
= &world_static
.instances
[ instance_id
];
20 world_init_blank( world
);
21 world
->status
= k_world_status_loading
;
23 vg_info( "Loading instance[%u]: %s\n", instance_id
, path
);
25 void *allocator
= NULL
;
26 if( instance_id
== 0 ) allocator
= world_static
.heap
;
27 else allocator
= world_static
.instances
[instance_id
-1].heap
;
29 u32 heap_availible
= vg_linear_remaining( allocator
);
30 u32 min_overhead
= sizeof(vg_linear_allocator
);
32 if( heap_availible
< (min_overhead
+1024) ){
33 vg_fatal_error( "out of memory" );
36 u32 size
= heap_availible
- min_overhead
;
37 void *heap
= vg_create_linear_allocator( allocator
, size
, VG_MEMORY_SYSTEM
);
40 mdl_context
*meta
= &world
->meta
;
42 mdl_open( meta
, path
, world
->heap
);
43 mdl_load_metadata_block( meta
, world
->heap
);
44 mdl_load_animation_block( meta
, world
->heap
);
45 mdl_load_mesh_block( meta
, world
->heap
);
47 mdl_load_array( meta
, &world
->ent_gate
, "ent_gate", heap
);
48 mdl_load_array( meta
, &world
->ent_camera
, "ent_camera", heap
);
49 mdl_load_array( meta
, &world
->ent_spawn
, "ent_spawn", heap
);
50 mdl_load_array( meta
, &world
->ent_light
, "ent_light", heap
);
51 mdl_load_array( meta
, &world
->ent_route_node
,"ent_route_node", heap
);
52 mdl_load_array( meta
, &world
->ent_path_index
,"ent_path_index", heap
);
53 mdl_load_array( meta
, &world
->ent_checkpoint
,"ent_checkpoint", heap
);
54 mdl_load_array( meta
, &world
->ent_route
, "ent_route", heap
);
55 mdl_load_array( meta
, &world
->ent_water
, "ent_water", heap
);
56 mdl_load_array( meta
, &world
->ent_audio_clip
,"ent_audio_clip", heap
);
57 mdl_load_array( meta
, &world
->ent_audio
, "ent_audio", heap
);
58 mdl_load_array( meta
, &world
->ent_volume
, "ent_volume", heap
);
59 mdl_load_array( meta
, &world
->ent_traffic
, "ent_traffic", heap
);
60 mdl_load_array( meta
, &world
->ent_marker
, "ent_marker", heap
);
61 mdl_load_array( meta
, &world
->ent_skateshop
, "ent_skateshop", heap
);
62 mdl_load_array( meta
, &world
->ent_swspreview
,"ent_swspreview", heap
);
63 mdl_load_array( meta
, &world
->ent_ccmd
, "ent_ccmd", heap
);
64 mdl_load_array( meta
, &world
->ent_objective
, "ent_objective", heap
);
65 mdl_load_array( meta
, &world
->ent_challenge
, "ent_challenge", heap
);
66 mdl_load_array( meta
, &world
->ent_relay
, "ent_relay", heap
);
67 mdl_load_array( meta
, &world
->ent_cubemap
, "ent_cubemap", heap
);
70 mdl_load_array( meta
, &infos
, "ent_worldinfo", vg_mem
.scratch
);
72 if( mdl_arrcount(&infos
) ){
73 world
->info
= *((ent_worldinfo
*)mdl_arritm(&infos
,0));
76 world
->info
.pstr_author
= 0;
77 world
->info
.pstr_desc
= 0;
78 world
->info
.pstr_name
= 0;
79 world
->info
.timezone
= 0.0f
;
86 world
->time
= (float)tm
->tm_min
/20.0f
+ (world
->info
.timezone
/24.0f
);
88 /* process resources from pack */
89 world_gen_load_surfaces( world
);
90 world_gen_routes_ent_init( world
);
91 world_gen_entities_init( world
);
94 world_gen_generate_meshes( world
);
95 world_gen_routes_generate( instance_id
);
96 world_gen_compute_light_indices( world
);
99 vg_async_call( async_world_postprocess
, world
, 0 );
103 struct world_load_complete_data
{
105 u32 instance_start
, instance_count
;
108 static void skaterift_world_load_done( void *payload
, u32 size
){
109 struct world_load_complete_data
*data
= payload
;
112 sav
.buf
= data
->save
.buf
;
113 sav
.len
= data
->save
.len
;
114 sav
.max
= data
->save
.len
;
116 for( u32 i
=0; i
<data
->instance_count
; i
++ ){
117 world_instance
*world
= &world_static
.instances
[ data
->instance_start
+i
];
118 world_entity_start( world
, &sav
);
121 world_static
.load_state
= k_world_loader_none
;
124 struct world_load_args
{
125 enum world_purpose purpose
;
130 * Does a complete world switch using the remaining free slots
132 static void skaterift_world_load_thread( void *_args
){
133 struct world_load_args
*args
= _args
;
134 enum world_purpose purpose
= args
->purpose
;
135 addon_reg
*reg
= args
->reg
;
137 if( purpose
== k_world_purpose_hub
) world_static
.addon_hub
= reg
;
138 else world_static
.addon_client
= reg
;
142 vg_strnull( &path
, path_buf
, 4096 );
145 addon_get_content_folder( reg
, &path
);
147 vg_str folder
= path
;
148 if( !vg_strgood( &folder
) ) {
149 vg_error( "Load target too long\n" );
153 char worlds
[3][4096];
157 if( !vg_dir_open(&dir
, folder
.buffer
) ){
158 vg_error( "opendir('%s') failed\n", folder
.buffer
);
162 while( vg_dir_next_entry(&dir
) ){
163 if( vg_dir_entry_type(&dir
) == k_vg_entry_type_file
){
164 const char *d_name
= vg_dir_entry_name(&dir
);
165 if( d_name
[0] == '.' ) continue;
167 vg_str file
= folder
;
168 vg_strcat( &file
, "/" );
169 vg_strcat( &file
, d_name
);
170 if( !vg_strgood( &file
) ) continue;
172 char *ext
= vg_strch( &file
, '.' );
174 if( strcmp(ext
,".mdl") ) continue;
177 vg_warn( "There are too many .mdl files in the map folder!(3)\n" );
181 strcpy( worlds
[i
++], file
.buffer
);
187 vg_warn( "There are no .mdl files in the map folder.\n" );
191 for( u32 j
=0; j
<i
; j
++ ){
192 vg_str name
= { .buffer
= worlds
[j
], .i
=strlen(worlds
[j
]),
194 char *fname
= vg_strch( &name
, '/' );
196 if( !strcmp( fname
+1, "main.mdl" ) ){
202 u32 instance_start
= 0, instance_count
= 1;
203 if( purpose
== k_world_purpose_client
) instance_start
= 1;
205 world_instance_load_mdl( instance_start
, worlds
[first_index
] );
207 /* TODO: Support multiply packed worlds */
209 world_loader
.generate_point_cloud
= 0;
210 for( u32 j
=0; j
<i
; j
++ ){
211 if( j
!= first_index
){
212 world_loader
.world_index
= j
+1;
213 world_load_mdl( worlds
[j
] );
218 vg_async_item
*final_call
=
219 vg_async_alloc( sizeof(struct world_load_complete_data
) );
221 struct world_load_complete_data
*data
= final_call
->payload
;
222 data
->instance_start
= instance_start
;
223 data
->instance_count
= instance_count
;
225 skaterift_world_get_save_path( purpose
, data
->save
.path
);
226 savedata_file_read( &data
->save
);
228 vg_async_dispatch( final_call
, skaterift_world_load_done
);
232 /* holding pattern before we can start loading the new world, since we might be
233 * waiting for audio to stop */
234 static void skaterift_change_client_world_preupdate(void){
235 for( u32 i
=1; i
<vg_list_size(world_static
.instances
); i
++ ){
236 world_instance
*inst
= &world_static
.instances
[i
];
238 if( inst
->status
== k_world_status_unloading
){
239 if( world_freeable( inst
) ){
246 if( vg_loader_availible() ){
247 vg_info( "worlds cleared, begining load\n" );
248 world_static
.load_state
= k_world_loader_load
;
250 vg_linear_clear( vg_async
.buffer
);
251 struct world_load_args
*args
=
252 vg_linear_alloc( vg_async
.buffer
, sizeof(struct world_load_args
) );
253 args
->purpose
= k_world_purpose_client
;
254 args
->reg
= world_static
.addon_client
;
256 /* this is replaces the already correct reg but we have to set it again
259 /* finally can start the loader */
260 vg_loader_start( skaterift_world_load_thread
, args
);
264 /* places all loaded worlds into unloading state */
265 static void skaterift_change_world_start( addon_reg
*reg
){
266 if( world_static
.active_instance
!= 0 )
267 vg_error( "Cannot change worlds while in non-root world\n" );
269 if( world_static
.addon_client
== reg
){
270 vg_warn( "World is already loaded\n" );
275 addon_alias_uid( ®
->alias
, buf
);
276 vg_info( "switching to: %s\n", buf
);
277 skaterift_autosave(1);
279 world_static
.load_state
= k_world_loader_preload
;
281 vg_linear_clear( vg_mem
.scratch
); /* ?? */
282 vg_info( "unloading old worlds\n" );
283 world_unlink_nonlocal( &world_static
.instances
[0] );
285 for( u32 i
=1; i
<vg_list_size(world_static
.instances
); i
++ ){
286 world_instance
*inst
= &world_static
.instances
[i
];
288 if( inst
->status
== k_world_status_loaded
){
289 inst
->status
= k_world_status_unloading
;
290 world_fadeout_audio( inst
);
294 world_static
.addon_client
= reg
;
295 network_send_item( k_netmsg_playeritem_world1
);
299 /* console command for the above function */
300 static int skaterift_change_world_command( int argc
, const char *argv
[] ){
301 if( !vg_loader_availible() ) return 0;
305 q
.type
= k_addon_type_world
;
307 vg_strncpy( argv
[0], q
.foldername
, 64, k_strncpy_always_add_null
);
309 u32 reg_id
= addon_match( &q
);
310 if( reg_id
!= 0xffffffff ){
311 addon_reg
*reg
= get_addon_from_index( k_addon_type_world
, reg_id
);
312 skaterift_change_world_start( reg
);
316 addon_alias_uid( &q
, buf
);
317 vg_error( "Addon '%s' is not installed or not found.\n", buf
);
326 * 1. to see if all audios owned by the world have been stopped
327 * 2. that this is the least significant world
329 static int world_freeable( world_instance
*world
){
330 if( world
->status
!= k_world_status_unloading
) return 0;
331 u8 world_id
= (world
- world_static
.instances
) + 1;
333 for( u32 i
=world_id
; i
<vg_list_size(world_static
.instances
); i
++ ){
334 if( world_static
.instances
[i
].status
!= k_world_status_unloaded
){
341 for( u32 i
=0; i
<AUDIO_CHANNELS
; i
++ ){
342 audio_channel
*ch
= &vg_audio
.channels
[i
];
344 if( ch
->allocated
&& (ch
->world_id
== world_id
)){
345 if( !audio_channel_finished( ch
) ){
356 * Free all resources for world instance
358 static void world_free( world_instance
*world
)
360 vg_info( "Free world @%p\n", world
);
363 mesh_free( &world
->mesh_route_lines
);
364 mesh_free( &world
->mesh_geo
);
365 mesh_free( &world
->mesh_no_collide
);
366 mesh_free( &world
->mesh_water
);
368 /* glDeleteBuffers silently ignores 0's and names that do not correspond to
369 * existing buffer objects.
371 glDeleteBuffers( 1, &world
->tbo_light_entities
);
372 glDeleteTextures( 1, &world
->tex_light_entities
);
373 glDeleteTextures( 1, &world
->tex_light_cubes
);
375 /* delete textures and meshes */
376 glDeleteTextures( world
->texture_count
, world
->textures
);
378 u32 world_index
= world
- world_static
.instances
;
380 vg_linear_del( world_static
.instances
[world_index
-1].heap
,
381 vg_linear_header(world
->heap
) );
384 for( u32 i
=0; i
<mdl_arrcount(&world
->ent_cubemap
); i
++ ){
385 ent_cubemap
*cm
= mdl_arritm(&world
->ent_cubemap
,i
);
386 glDeleteTextures( 1, &cm
->texture_id
);
387 glDeleteFramebuffers( 1, &cm
->framebuffer_id
);
388 glDeleteRenderbuffers( 1, &cm
->renderbuffer_id
);
391 world
->status
= k_world_status_unloaded
;
395 * reset the world structure without deallocating persistent buffers
396 * TODO: Make this a memset(0), and have persistent items live in a static loc
398 static void world_init_blank( world_instance
*world
)
400 memset( &world
->meta
, 0, sizeof(mdl_context
) );
402 world
->textures
= NULL
;
403 world
->texture_count
= 0;
404 world
->surfaces
= NULL
;
405 world
->surface_count
= 0;
407 world
->geo_bh
= NULL
;
408 world
->entity_bh
= NULL
;
409 world
->entity_list
= NULL
;
410 world
->rendering_gate
= NULL
;
412 world
->water
.enabled
= 0;
415 /* default lighting conditions
416 * -------------------------------------------------------------*/
417 struct ub_world_lighting
*state
= &world
->ub_lighting
;
419 state
->g_light_preview
= 0;
420 state
->g_shadow_samples
= 8;
421 state
->g_water_fog
= 0.04f
;
423 v4_zero( state
->g_water_plane
);
424 v4_zero( state
->g_depth_bounds
);
426 state
->g_shadow_length
= 9.50f
;
427 state
->g_shadow_spread
= 0.65f
;
429 v3_copy( (v3f
){0.37f
, 0.54f
, 0.97f
}, state
->g_daysky_colour
);
430 v3_copy( (v3f
){0.03f
, 0.05f
, 0.20f
}, state
->g_nightsky_colour
);
431 v3_copy( (v3f
){1.00f
, 0.32f
, 0.01f
}, state
->g_sunset_colour
);
432 v3_copy( (v3f
){0.13f
, 0.17f
, 0.35f
}, state
->g_ambient_colour
);
433 v3_copy( (v3f
){0.25f
, 0.17f
, 0.51f
}, state
->g_sunset_ambient
);
434 v3_copy( (v3f
){1.10f
, 0.89f
, 0.35f
}, state
->g_sun_colour
);
437 #endif /* WORLD_LOAD_C */