a couple fixmes related to allocations

diff --git a/font.h b/font.h
index 75f2573c29f4bd9d292531d605b5529849ec6bab..eaba149b68d06bd7514fd9fc0b4d250ca06e3b2b 100644 (file)
--- a/font.h
+++ b/font.h
@@ -32,8 +32,13 @@ VG_STATIC void font3d_load( font3d *font, const char *mdl_path, void *alloc )
 
    vg_linear_clear( vg_mem.scratch );
    mdl_load_mesh_block( &font->mdl, vg_mem.scratch );
-   mdl_load_pack_block( &font->mdl, vg_mem.scratch );
-   mdl_close( &font->mdl );
+
+   if( !mdl_arrcount( &font->mdl.textures ) )
+      vg_fatal_exit_loop( "No texture in font file" );
+
+   mdl_texture *tex0 = mdl_arritm( &font->mdl.textures, 0 );
+   void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
+   mdl_fread_pack_file( &font->mdl, &tex0->file, data );
 
    vg_acquire_thread_sync();
    {
@@ -44,16 +49,16 @@ VG_STATIC void font3d_load( font3d *font, const char *mdl_path, void *alloc )
 
       /* upload first texture */
       font->texture = vg_tex2d_new();
-      mdl_texture *tex0 = mdl_arritm( &font->mdl.textures, 0 );
 
       vg_tex2d_set_error();
-      vg_tex2d_qoi( mdl_arritm( &font->mdl.pack, tex0->file.pack_offset ),
-                    tex0->file.pack_size,
+      vg_tex2d_qoi( data, tex0->file.pack_size,
                     mdl_pstr( &font->mdl, tex0->file.pstr_path ));
       vg_tex2d_nearest();
       vg_tex2d_repeat();
    }
    vg_release_thread_sync();
+
+   mdl_close( &font->mdl );
 }
 
 VG_STATIC void font3d_init(void)

diff --git a/model.h b/model.h
index b7e0e96e6f43a512cb52e5282f767ce699ef2d65..05790c655d204ed18668b8e1b101c4f03cba2989 100644 (file)
--- a/model.h
+++ b/model.h
@@ -209,10 +209,12 @@ struct mdl_context
 
    /* mesh buffers */
    verts,
-   indices,
+   indices;
+
+   u32 pack_base_offset;
    
    /* pack data */
-   pack;
+   //pack;
 };
 
 
@@ -227,6 +229,26 @@ VG_STATIC void mdl_load_fatal_corrupt( mdl_context *mdl )
  * Model implementation
  */
 
+VG_STATIC u32 mdl_query_array_size( mdl_array *arr )
+{
+   if( arr->item_count ){
+      u32 size = arr->item_size*arr->item_count;
+      return vg_align8(size);
+   }
+   else
+      return 0;
+}
+
+VG_STATIC 
+void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst )
+{
+   fseek( mdl->file, mdl->pack_base_offset+info->pack_offset, SEEK_SET );
+   u64 l = fread( dst, info->pack_size, 1, mdl->file );
+
+   if( l != 1 )
+      mdl_load_fatal_corrupt( mdl );
+}
+
 VG_STATIC void mdl_load_array_file( mdl_context *mdl, mdl_array_ptr *ptr,
                                     mdl_array *arr, void *lin_alloc )
 {
@@ -257,22 +279,34 @@ VG_STATIC u32 mdl_arrcount( mdl_array_ptr *arr )
    return arr->count;
 }
 
-VG_STATIC int mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
-                              const char *name, void *lin_alloc )
+VG_STATIC mdl_array *mdl_find_array( mdl_context *mdl, const char *name )
 {
    for( u32 i=0; i<mdl_arrcount(&mdl->index); i++ ){
       mdl_array *arr = mdl_arritm( &mdl->index, i );
       
       if( !strncmp(arr->name,name,16) ){
-         mdl_load_array_file( mdl, ptr, arr, lin_alloc );
-         return 1;
+         return arr;
       }
    }
 
-   ptr->data = NULL;
-   ptr->count = 0;
-   ptr->stride = 0;
-   return 0;
+   return NULL;
+}
+
+VG_STATIC int mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
+                              const char *name, void *lin_alloc )
+{
+   mdl_array *arr = mdl_find_array( mdl, name );
+
+   if( arr ){
+      mdl_load_array_file( mdl, ptr, arr, lin_alloc );
+      return 1;
+   }
+   else{
+      ptr->data = NULL;
+      ptr->count = 0;
+      ptr->stride = 0;
+      return 0;
+   }
 }
 
 VG_STATIC int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
@@ -306,10 +340,12 @@ VG_STATIC int mdl_load_animation_block( mdl_context *mdl, void *lin_alloc )
    return mdl_load_array( mdl, &mdl->keyframes, "mdl_keyframe", lin_alloc );
 }
 
+#if 0
 VG_STATIC int mdl_load_pack_block( mdl_context *mdl, void *lin_alloc )
 {
    return mdl_load_array( mdl, &mdl->pack, "pack", lin_alloc );
 }
+#endif
 
 /*
  * if calling mdl_open, and the file does not exist, the game will fatal quit
@@ -329,6 +365,10 @@ VG_STATIC void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
       mdl_load_fatal_corrupt( mdl );
 
    mdl_load_array_file( mdl, &mdl->index, &mdl->info.index, lin_alloc );
+
+   mdl_array *pack = mdl_find_array( mdl, "pack" );
+   if( pack ) mdl->pack_base_offset = pack->file_offset;
+   else mdl->pack_base_offset = 0;
 }
 
 /*

diff --git a/shaders/model_character_view.h b/shaders/model_character_view.h
index f5a701dad1efa3c212edc644282a7a86e10d3e30..cf93a55a5803e1daa1666c3bf5aea36e49f86e6c 100644 (file)
--- a/shaders/model_character_view.h
+++ b/shaders/model_character_view.h
@@ -442,7 +442,6 @@ static struct vg_shader _shader_model_character_view = {
 "      discard;\n"
 "\n"
 "   oColour = vec4( composite, opacity );\n"
-"   //oColour = vec4( vec3(back_depth), 1.0 );\n"
 "}\n"
 ""},
 };

diff --git a/skaterift.c b/skaterift.c
index 957498ab846e48548116da849c1b380108f46548..a01f67a37859aa60902dc506696832bc05930127 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -166,8 +166,8 @@ VG_STATIC void vg_load(void)
    /* 'systems' are completely loaded now */
 
    /* load home world */
-   //world_load( &world_global.worlds[0], "maps/mp_gridmap.mdl" );
-   world_load( &world_global.worlds[0], "maps/mp_mtzero.mdl" );
+   world_load( 0, "maps/mp_gridmap.mdl" );
+   world_load( 1, "maps/mp_mtzero.mdl" );
 
 #if 0
    world_load( &world_global.worlds[1], "maps/mp_gridmap.mdl" );

diff --git a/world.h b/world.h
index 622837d778728f42a6c1eb95a6aa2b59ecd9336d..c7485d17b4bf9fe7622811fdef8be3a8afa9be1a 100644 (file)
--- a/world.h
+++ b/world.h
@@ -60,6 +60,7 @@ struct world_instance {
     * -------------------------------------------------------
     */
 
+   void *heap;
    char  world_name[ 64 ];
 
    struct{
@@ -184,12 +185,12 @@ struct world_instance {
    rb_object rb_geo;
 };
 
-VG_STATIC struct world_global{
+struct world_global{
    /*
     * Allocated as system memory
     * --------------------------------------------------------------------------
     */
-   void *generic_heap;
+   void *heap;
 
    /* rendering */
    glmesh skydome;
@@ -250,9 +251,8 @@ VG_STATIC struct world_global{
    }
    text_particles[6*4];
    u32 text_particle_count;
-
 }
-world_global;
+static world_global;
 
 VG_STATIC world_instance *get_active_world( void )
 {
@@ -399,9 +399,8 @@ VG_STATIC void world_init(void)
 
    /* Allocate dynamic world memory arena */
    u32 max_size = 76*1024*1024;
-   world_global.generic_heap = vg_create_linear_allocator( vg_mem.rtmemory, 
-                                                           max_size,
-                                                           VG_MEMORY_SYSTEM );
+   world_global.heap = vg_create_linear_allocator( vg_mem.rtmemory, max_size,
+                                                   VG_MEMORY_SYSTEM );
 }
 
 typedef struct ent_call ent_call;

diff --git a/world_gen.h b/world_gen.h
index ded2efefd4cabff9037c76e7560e5a8285eca592..2371fa52af135755ac9e6ea54139eed6ab751cba 100644 (file)
--- a/world_gen.h
+++ b/world_gen.h
@@ -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 */

diff --git a/world_routes.h b/world_routes.h
index acb58131436f80b1a43ef7864a561410d22e5ce4..00dee4ea0c79d742a78ad3c023cce8d3f1ed7f65 100644 (file)
--- a/world_routes.h
+++ b/world_routes.h
@@ -455,7 +455,7 @@ VG_STATIC void world_routes_create_mesh( world_instance *world, u32 route_id )
 VG_STATIC void world_routes_generate( world_instance *world )
 {
    vg_info( "Generating route meshes\n" );
-   world->scene_lines = scene_init( world_global.generic_heap, 200000, 300000 );
+   world->scene_lines = scene_init( world->heap, 200000, 300000 );
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
       ent_gate *gate = mdl_arritm( &world->ent_gate, i );
@@ -504,7 +504,7 @@ VG_STATIC void world_routes_generate( world_instance *world )
       scene_upload( world->scene_lines, &world->mesh_route_lines );
    }
    vg_release_thread_sync();
-   vg_linear_del( world_global.generic_heap, world->scene_lines );
+   vg_linear_del( world->heap, world->scene_lines );
 
    world_routes_clear( world );
 }