a couple fixmes related to allocations
[carveJwlIkooP6JGAAIwe30JlM.git] / world_gen.h
index ded2efefd4cabff9037c76e7560e5a8285eca592..2371fa52af135755ac9e6ea54139eed6ab751cba 100644 (file)
@@ -7,7 +7,7 @@
 
 #include "world.h"
 
-VG_STATIC void world_load( world_instance *world, const char *path );
+VG_STATIC void world_load( u32 index, const char *path );
 
 VG_STATIC void world_add_all_if_material( m4x3f transform, scene *pscene, 
                                           mdl_context *mdl, u32 id )
@@ -131,7 +131,7 @@ VG_STATIC void world_generate( world_instance *world )
    /* 
     * Compile meshes into the world scenes
     */
-   world->scene_geo = scene_init( world_global.generic_heap, 320000, 1200000 );
+   world->scene_geo = scene_init( world->heap, 320000, 1200000 );
 
    m4x3f midentity;
    m4x3_identity( midentity );
@@ -154,7 +154,7 @@ VG_STATIC void world_generate( world_instance *world )
    }
 
    /* compress that bad boy */
-   world->scene_geo = scene_fix( world_global.generic_heap, world->scene_geo );
+   world->scene_geo = scene_fix( world->heap, world->scene_geo );
 
    vg_acquire_thread_sync();
    {
@@ -163,8 +163,7 @@ VG_STATIC void world_generate( world_instance *world )
    vg_release_thread_sync();
 
    /* setup spacial mapping and rigidbody */
-   world->geo_bh = scene_bh_create( world_global.generic_heap, 
-                                    world->scene_geo );
+   world->geo_bh = scene_bh_create( world->heap, world->scene_geo );
 
    v3_zero( world->rb_geo.rb.co );
    v3_zero( world->rb_geo.rb.v );
@@ -181,8 +180,7 @@ VG_STATIC void world_generate( world_instance *world )
     */
    vg_info( "Generating non-collidable geometry\n" );
 
-   world->scene_no_collide = scene_init( world_global.generic_heap, 
-                                         200000, 500000 );
+   world->scene_no_collide = scene_init( world->heap, 200000, 500000 );
 
    for( u32 i=0; i<world->surface_count; i++ ){
       struct world_surface *mat = &world->surfaces[ i ];
@@ -205,7 +203,7 @@ VG_STATIC void world_generate( world_instance *world )
    }
    vg_release_thread_sync();
 
-   vg_linear_del( world_global.generic_heap, world->scene_no_collide );
+   vg_linear_del( world->heap, world->scene_no_collide );
    world->scene_no_collide = NULL;
 }
 
@@ -270,7 +268,7 @@ VG_STATIC void world_compute_light_indices( world_instance *world )
 
    int total_cubes = icubes_count[0]*icubes_count[1]*icubes_count[2];
 
-   u32 *cubes_index = vg_linear_alloc( world_global.generic_heap, 
+   u32 *cubes_index = vg_linear_alloc( world->heap,
                                        vg_align8(total_cubes*sizeof(u32)*2) );
                                        
    vg_info( "Computing light cubes (%d) [%f %f %f] -> [%f %f %f]\n", 
@@ -376,7 +374,7 @@ VG_STATIC void world_compute_light_indices( world_instance *world )
    glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 
-   vg_linear_del( world_global.generic_heap, cubes_index );
+   vg_linear_del( world->heap, cubes_index );
 
    vg_release_thread_sync();
 }
@@ -529,7 +527,7 @@ VG_STATIC void world_process_resources( world_instance *world )
    world->texture_count = 0;
 
    world->texture_count = world->meta.textures.count+1;
-   world->textures = vg_linear_alloc( world_global.generic_heap,
+   world->textures = vg_linear_alloc( world->heap,
                               vg_align8(sizeof(GLuint)*world->texture_count) );
 
    vg_acquire_thread_sync();
@@ -549,10 +547,13 @@ VG_STATIC void world_process_resources( world_instance *world )
          }
 
          vg_linear_clear( vg_mem.scratch );
+         void *src_data = vg_linear_alloc( vg_mem.scratch, 
+                                           tex->file.pack_size );
+         mdl_fread_pack_file( &world->meta, &tex->file, src_data );
+
          world->textures[i+1] = vg_tex2d_new();
          vg_tex2d_set_error();
-         vg_tex2d_qoi( mdl_arritm( &world->meta.pack, tex->file.pack_offset ),
-                       tex->file.pack_size,
+         vg_tex2d_qoi( src_data, tex->file.pack_size,
                        mdl_pstr( &world->meta, tex->file.pstr_path ));
          vg_tex2d_nearest();
          vg_tex2d_repeat();
@@ -563,7 +564,7 @@ VG_STATIC void world_process_resources( world_instance *world )
    vg_info( "Loading materials\n" );
 
    world->surface_count = world->meta.materials.count+1;
-   world->surfaces = vg_linear_alloc( world_global.generic_heap,
+   world->surfaces = vg_linear_alloc( world->heap,
                vg_align8(sizeof(struct world_surface)*world->surface_count) );
 
    /* error material */
@@ -576,7 +577,7 @@ VG_STATIC void world_process_resources( world_instance *world )
    }
 }
 
-VG_STATIC void world_unload( world_instance *world )
+VG_STATIC void world_free( world_instance *world )
 {
    vg_acquire_thread_sync();
 
@@ -592,25 +593,9 @@ VG_STATIC void world_unload( world_instance *world )
    glDeleteTextures( 1, &world->tex_light_entities );
    glDeleteTextures( 1, &world->tex_light_cubes );
 
-   /* FIXME: CANT DO THIS HERE */
-   /*        whynot? */
-   /*        oh this should be moved to a global function */
-   world_global.time = 0.0;
-   world_global.rewind_from = 0.0;
-   world_global.rewind_to = 0.0;
-   world_global.last_use = 0.0;
-   world_global.sfd.active_route_board = 0;
-
    /* delete textures and meshes */
    glDeleteTextures( world->texture_count, world->textures );
 
-   /* delete the entire block of memory */
-   /* FIXME: WE CANT DO THIS SHIT ANYMORE, NEED TO DEALLOC FROM ABOVE */
-#if 0
-   vg_linear_clear( world->dynamic_vgl );
-   vg_linear_clear( world->audio_vgl );
-#endif
-
    vg_release_thread_sync();
 }
 
@@ -708,8 +693,14 @@ VG_STATIC void world_entities_init( world_instance *world )
             u32 size = clip->file.pack_size,
                 offset = clip->file.pack_offset;
 
-            /* FIXME: Ditchable asset! */
-            void *data = mdl_arritm(&world->meta.pack, clip->file.pack_offset);
+            /* embedded files are fine to clear the scratch buffer, only
+             * external audio uses it */
+
+            vg_linear_clear( vg_mem.scratch );
+            void *data = vg_linear_alloc( vg_mem.scratch, 
+                                          clip->file.pack_size );
+
+            mdl_fread_pack_file( &world->meta, &clip->file, data );
 
             clip->clip.path = NULL;
             clip->clip.flags = audio->flags;
@@ -723,74 +714,67 @@ VG_STATIC void world_entities_init( world_instance *world )
             clip->clip.size = 0;
          }
 
-         audio_clip_load( &clip->clip, world_global.generic_heap );
+         audio_clip_load( &clip->clip, world->heap );
       }
    }
 }
 
-VG_STATIC void world_load( world_instance *world, const char *path )
+VG_STATIC void world_load( u32 index, const char *path )
 {
-   world_unload( world );
+   world_instance *world = &world_global.worlds[index];
    world_init_blank( world );
 
    vg_info( "Loading world: %s\n", path );
 
-   mdl_open( &world->meta, path, world_global.generic_heap );
-   mdl_load_metadata_block( &world->meta, world_global.generic_heap );
-   mdl_load_animation_block( &world->meta, world_global.generic_heap );
-   mdl_load_mesh_block( &world->meta, world_global.generic_heap );
-
-   /* TODO: This should get a seperate memory area */
-   mdl_load_pack_block( &world->meta, world_global.generic_heap );
-
-   mdl_load_array( &world->meta, &world->ent_gate, 
-                   "ent_gate", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_spawn,
-                   "ent_spawn", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_light,
-                   "ent_light", world_global.generic_heap );
-
-   mdl_load_array( &world->meta, &world->ent_route_node,
-                   "ent_route_node", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_path_index,
-                   "ent_path_index", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_checkpoint,
-                   "ent_checkpoint", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_route,
-                   "ent_route", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_water,
-                   "ent_water", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_audio_clip,
-                   "ent_audio_clip", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_audio,
-                   "ent_audio", world_global.generic_heap );
-   mdl_load_array( &world->meta, &world->ent_volume,
-                   "ent_volume", world_global.generic_heap );
-
-   mdl_close( &world->meta );
+   void *allocator = NULL;
+   if( index == 0 ) allocator = world_global.heap;
+   else allocator = world_global.worlds[index-1].heap;
+
+   u32 heap_availible = vg_linear_remaining( allocator );
+   u32 min_overhead = sizeof(vg_linear_allocator);
+
+   if( heap_availible < (min_overhead+1024) ){
+      vg_fatal_exit_loop( "out of memory" );
+   }
+
+   u32 size = heap_availible - min_overhead;
+   void *heap = vg_create_linear_allocator( allocator, size, 
+                                            VG_MEMORY_SYSTEM );
+
+   world->heap = heap;
+   mdl_context *meta = &world->meta;
+
+   mdl_open( meta, path, world->heap );
+   mdl_load_metadata_block( meta, world->heap );
+   mdl_load_animation_block( meta, world->heap );
+   mdl_load_mesh_block( meta, world->heap );
+
+   mdl_load_array( meta, &world->ent_gate,      "ent_gate",       heap );
+   mdl_load_array( meta, &world->ent_spawn,     "ent_spawn",      heap );
+   mdl_load_array( meta, &world->ent_light,     "ent_light",      heap );
+   mdl_load_array( meta, &world->ent_route_node,"ent_route_node", heap );
+   mdl_load_array( meta, &world->ent_path_index,"ent_path_index", heap );
+   mdl_load_array( meta, &world->ent_checkpoint,"ent_checkpoint", heap );
+   mdl_load_array( meta, &world->ent_route,     "ent_route",      heap );
+   mdl_load_array( meta, &world->ent_water,     "ent_water",      heap );
+   mdl_load_array( meta, &world->ent_audio_clip,"ent_audio_clip", heap );
+   mdl_load_array( meta, &world->ent_audio,     "ent_audio",      heap );
+   mdl_load_array( meta, &world->ent_volume,    "ent_volume",     heap );
 
    /* process resources from pack */
    world_process_resources( world );
 
-#if 0
-   /* dynamic allocations */
-   world_ents_allocate( world );
-   world_routes_allocate( world );
-
-   /* meta processing */
-#endif
    world_routes_ent_init( world );
    world_entities_init( world );
-   world->volume_bh = bh_create( world_global.generic_heap,
-                                 &bh_system_volumes,
-                                 world,
-                                 mdl_arrcount( &world->ent_volume ),
-                                 1 );
+   world->volume_bh = bh_create( heap, &bh_system_volumes, world,
+                                 mdl_arrcount( &world->ent_volume ), 1 );
    
    /* main bulk */
    world_generate( world );
    world_routes_generate( world );
    world_post_process( world );
+
+   mdl_close( meta );
 }
 
 #endif /* WORLD_GEN_H */