From 2329044d44a5aff035b01926f7901d9e89ad284e Mon Sep 17 00:00:00 2001 From: hgn Date: Sun, 23 Jul 2023 02:47:42 +0100 Subject: [PATCH] yet again more world load revision --- save.c | 2 +- save.h | 4 +-- skaterift.c | 15 ++++++--- world_entity.c | 22 +++++++++++++ world_entity.h | 3 ++ world_gen.c | 15 ++------- world_gen.h | 2 +- world_load.c | 84 +++++++++++++++++++++++++++++++++++++++++--------- 8 files changed, 111 insertions(+), 36 deletions(-) diff --git a/save.c b/save.c index e31816e..094095c 100644 --- a/save.c +++ b/save.c @@ -24,7 +24,7 @@ static void savedata_read( struct savedata *sav ){ } else{ sav->len = 0; - vg_error( "Error reading savedata (%s)\n", sav->path ); + vg_warn( "Error reading savedata (%s)\n", sav->path ); } } diff --git a/save.h b/save.h index 7ed944c..25b9548 100644 --- a/save.h +++ b/save.h @@ -11,8 +11,8 @@ struct savedata { #include "ent_skateshop.h" -static void skaterift_write_savedata(void); -static void skaterift_read_savedata(void); +static void savedata_read( struct savedata *sav ); +static void savedata_write_thread( void *file ); static void skaterift_read_main_savedata( struct savedata *sav ); static void skaterift_write_main_savedata(void); diff --git a/skaterift.c b/skaterift.c index 25957d5..c9afd0b 100644 --- a/skaterift.c +++ b/skaterift.c @@ -134,9 +134,12 @@ static void skaterift_restore_state(void){ if( reg_id != 0xffffffff ){ addon_reg *reg = get_addon_from_index( k_addon_type_world, reg_id ); - world_static.addon_client = reg; world_static.load_state = k_world_loader_load; - skaterift_client_world_changer_thread(NULL); + struct world_load_args args = { + .purpose = k_world_purpose_client, + .reg = reg + }; + skaterift_world_load_thread( &args ); world_static.active_instance = vg_msg_seekkvu32( &world, "index", 0 ); world_static.active_trigger_volume_count = 0; @@ -226,8 +229,12 @@ VG_STATIC void vg_load(void){ } /* load home/permanent world manually */ - world_static.addon_hub = spawn; - world_instance_load_mdl( 0, "maps/mp_spawn/main.mdl" ); + world_static.load_state = k_world_loader_load; + struct world_load_args args = { + .purpose = k_world_purpose_hub, + .reg = spawn + }; + skaterift_world_load_thread( &args ); vg_async_call( async_skaterift_player_start, NULL, 0 ); vg_async_stall(); diff --git a/world_entity.c b/world_entity.c index d3c6a8c..7ffa1d6 100644 --- a/world_entity.c +++ b/world_entity.c @@ -5,6 +5,7 @@ #include "entity.h" #include "world.h" #include "world_load.h" +#include "save.h" VG_STATIC void world_gen_entities_init( world_instance *world ){ /* lights */ @@ -438,4 +439,25 @@ VG_STATIC void entity_bh_closest( void *user, u32 item_index, v3f point, } } +VG_STATIC void world_entity_start( world_instance *world, + struct savedata *sav ){ + vg_info( "Start instance %p\n", world ); + + world->probabilities[ k_probability_curve_constant ] = 1.0f; + for( u32 i=0; ient_audio); i++ ){ + ent_audio *audio = mdl_arritm(&world->ent_audio,i); + if( audio->flags & AUDIO_FLAG_AUTO_START ){ + ent_call call; + call.data = NULL; + call.function = k_ent_function_trigger; + call.id = mdl_entity_id( k_ent_audio, i ); + entity_call( world, &call ); + } + } +} + +VG_STATIC void async_world_entity_start( void *payload, u32 size ){ + +} + #endif /* WORLD_ENTITY_C */ diff --git a/world_entity.h b/world_entity.h index bbcfbe2..63cab47 100644 --- a/world_entity.h +++ b/world_entity.h @@ -4,12 +4,15 @@ #include "world.h" #include "entity.h" #include "bvh.h" +#include "save.h" VG_STATIC void world_gen_entities_init( world_instance *world ); VG_STATIC ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name ); VG_STATIC ent_spawn *world_find_closest_spawn( world_instance *world, v3f position ); +VG_STATIC void world_entity_start( world_instance *world, + struct savedata *sav ); VG_STATIC void ent_volume_call( world_instance *world, ent_call *call ); VG_STATIC void ent_audio_call( world_instance *world, ent_call *call ); diff --git a/world_gen.c b/world_gen.c index 81ad00c..b7aaf50 100644 --- a/world_gen.c +++ b/world_gen.c @@ -494,7 +494,7 @@ VG_STATIC void world_gen_compute_light_indices( world_instance *world ){ /* * Rendering pass needed to complete the world */ -VG_STATIC void async_world_postprocess_render( void *payload, u32 _size ){ +VG_STATIC void async_world_postprocess( void *payload, u32 _size ){ /* create scene lighting buffer */ world_instance *world = payload; @@ -604,18 +604,7 @@ VG_STATIC void async_world_postprocess_render( void *payload, u32 _size ){ glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(struct ub_world_lighting), &world->ub_lighting ); - /* yes we are using this as the entity begin thing. FIXME */ - world->probabilities[ k_probability_curve_constant ] = 1.0f; - for( u32 i=0; ient_audio); i++ ){ - ent_audio *audio = mdl_arritm(&world->ent_audio,i); - if( audio->flags & AUDIO_FLAG_AUTO_START ){ - ent_call call; - call.data = NULL; - call.function = k_ent_function_trigger; - call.id = mdl_entity_id( k_ent_audio, i ); - entity_call( world, &call ); - } - } + world->status = k_world_status_loaded; } /* Loads textures from the pack file */ diff --git a/world_gen.h b/world_gen.h index 4294368..5e2f0b1 100644 --- a/world_gen.h +++ b/world_gen.h @@ -14,6 +14,6 @@ VG_STATIC void world_init_blank( world_instance *world ); VG_STATIC void world_gen_load_surfaces( world_instance *world ); VG_STATIC void world_gen_generate_meshes( world_instance *world ); VG_STATIC void world_gen_compute_light_indices( world_instance *world ); -VG_STATIC void async_world_postprocess_render( void *payload, u32 _size ); +VG_STATIC void async_world_postprocess( void *payload, u32 _size ); #endif /* WORLD_GEN_H */ diff --git a/world_load.c b/world_load.c index f815fa5..0b96ad8 100644 --- a/world_load.c +++ b/world_load.c @@ -6,6 +6,7 @@ #include "world_gate.h" #include "ent_skateshop.h" #include "addon.h" +#include "save.h" /* * load the .mdl file located in path as a world instance @@ -17,7 +18,7 @@ VG_STATIC void world_instance_load_mdl( u32 instance_id, const char *path ){ world_init_blank( world ); world->status = k_world_status_loading; - vg_info( "Loading world: %s\n", path ); + vg_info( "Loading instance[%u]: %s\n", instance_id, path ); void *allocator = NULL; if( instance_id == 0 ) allocator = world_static.heap; @@ -90,27 +91,55 @@ VG_STATIC void world_instance_load_mdl( u32 instance_id, const char *path ){ world_gen_generate_meshes( world ); world_gen_routes_generate( instance_id ); world_gen_compute_light_indices( world ); - vg_async_call( async_world_postprocess_render, world, 0 ); - vg_async_stall(); - mdl_close( meta ); - world->status = k_world_status_loaded; + + vg_async_call( async_world_postprocess, world, 0 ); + vg_async_stall(); } -static void skaterift_client_world_change_done( void *payload, u32 size ){ + +struct world_load_complete_data{ + struct savedata save; + u32 instance_start, instance_count; +}; + +static void skaterift_world_load_done( void *payload, u32 size ){ + struct world_load_complete_data *data = payload; + + for( u32 i=0; iinstance_count; i++ ){ + world_instance *world = &world_static.instances[ data->instance_start+i ]; + world_entity_start( world, &data->save ); + } + world_static.load_state = k_world_loader_none; } +struct world_load_args { + enum world_purpose{ + k_world_purpose_hub, + k_world_purpose_client + } + purpose; + addon_reg *reg; +}; + /* * Does a complete world switch using the remaining free slots */ -static void skaterift_client_world_changer_thread( void *_ ){ +static void skaterift_world_load_thread( void *_args ){ + struct world_load_args *args = _args; + enum world_purpose purpose = args->purpose; + addon_reg *reg = args->reg; + + if( purpose == k_world_purpose_hub ) world_static.addon_hub = reg; + else world_static.addon_client = reg; + char path_buf[4096]; vg_str path; vg_strnull( &path, path_buf, 4096 ); - assert( world_static.addon_client ); - addon_get_content_folder( world_static.addon_client, &path ); + assert( reg ); + addon_get_content_folder( reg, &path ); vg_str folder = path; if( !vg_strgood( &folder ) ) { @@ -167,7 +196,10 @@ static void skaterift_client_world_changer_thread( void *_ ){ } } - world_instance_load_mdl( 1, worlds[first_index] ); + u32 instance_start = 0, instance_count = 1; + if( purpose == k_world_purpose_client ) instance_start = 1; + + world_instance_load_mdl( instance_start, worlds[first_index] ); /* TODO: Support multiply packed worlds */ #if 0 @@ -180,7 +212,18 @@ static void skaterift_client_world_changer_thread( void *_ ){ } #endif - vg_async_call( skaterift_client_world_change_done, NULL, 0 ); + vg_async_item *final_call = + vg_async_alloc( sizeof(struct world_load_complete_data) ); + + struct world_load_complete_data *data = final_call->payload; + data->instance_start = instance_start; + data->instance_count = instance_count; + strcpy( data->save.path, "temp_fuckyou.bkv" ); + + savedata_read( &data->save ); + + vg_async_dispatch( final_call, skaterift_world_load_done ); + vg_async_stall(); } /* holding pattern before we can start loading the new world, since we might be @@ -197,11 +240,22 @@ static void skaterift_change_client_world_preupdate(void){ } } - vg_info( "worlds cleared, begining load\n" ); - world_static.load_state = k_world_loader_load; + if( vg_loader_availible() ){ + vg_info( "worlds cleared, begining load\n" ); + world_static.load_state = k_world_loader_load; + + vg_linear_clear( vg_async.buffer ); + struct world_load_args *args = + vg_linear_alloc( vg_async.buffer, sizeof(struct world_load_args) ); + args->purpose = k_world_purpose_client; + args->reg = world_static.addon_client; - /* finally can start the loader */ - vg_loader_start( skaterift_client_world_changer_thread, NULL ); + /* this is replaces the already correct reg but we have to set it again + * TOO BAD */ + + /* finally can start the loader */ + vg_loader_start( skaterift_world_load_thread, args ); + } } /* places all loaded worlds into unloading state */ -- 2.25.1