compress array file interface a bit

diff --git a/content_skaterift/metascenes/skater.ms b/content_skaterift/metascenes/skater.ms
index d14e95623f7cca38b981ff1f8d586ffd644c9fdb..1e289a146d8a41dd7924c00f2ab5a767c90a9e60 100644 (file)
Binary files a/content_skaterift/metascenes/skater.ms and b/content_skaterift/metascenes/skater.ms differ

diff --git a/content_skaterift/metascenes/test_scene.ms b/content_skaterift/metascenes/test_scene.ms
index a112cfadd3f981cfcb9e368b81115cb737e01e34..da5827d6e481604c6b10b6bf7d0ae522ee4ff014 100644 (file)
Binary files a/content_skaterift/metascenes/test_scene.ms and b/content_skaterift/metascenes/test_scene.ms differ

diff --git a/skaterift_blender/sr_bin.py b/skaterift_blender/sr_bin.py
index cd9187372755e96e9978ccd05a838d6fdf7cabbd..729a2ef115ad6d4dde847517515fa382f961086b 100644 (file)
--- a/skaterift_blender/sr_bin.py
+++ b/skaterift_blender/sr_bin.py
@@ -78,6 +78,12 @@ class array_file_meta(Structure):
                ("name",c_byte*16)]
 #}
 
+class array_file_header(Structure):
+#{
+   _fields_ = [("version",c_uint32),
+               ("index",array_file_meta)]
+#}
+
 def str_into_buf( str, buf ):
 #{
    for i in range(len(str)):

diff --git a/skaterift_blender/sr_main.py b/skaterift_blender/sr_main.py
index 289bf1e866867468c17379179ae49326ff3c43ef..df5d9fc75a0fd86c512e7e05d830901da2be0f0b 100644 (file)
--- a/skaterift_blender/sr_main.py
+++ b/skaterift_blender/sr_main.py
@@ -176,12 +176,6 @@ class mdl_texture(Structure):
                ("glname",c_uint32)]
 #}
 
-class mdl_header(Structure):
-#{
-   _fields_ = [("version",c_uint32),
-               ("index",array_file_meta)]
-#}
-
 class ent_spawn(Structure):
 #{
    _fields_ = [("transform",mdl_transform),
@@ -2034,7 +2028,7 @@ def sr_compile( collection ):
 
    os.makedirs(os.path.dirname(path),exist_ok=True)
 
-   header = mdl_header()
+   header = array_file_header()
    header.version = MDL_VERSION_NR
    array_file_write( path, header, arrays )
 

diff --git a/skaterift_blender/sr_metascene.py b/skaterift_blender/sr_metascene.py
index cf076bf7495fcb1c9d6afa256ea498ab4dfe53b7..6efeb95f9241a91a3ff8cb1f11960b1a0d1b782f 100644 (file)
--- a/skaterift_blender/sr_metascene.py
+++ b/skaterift_blender/sr_metascene.py
@@ -37,11 +37,9 @@ def _ms_compiler_init():
    _ms_compiler.overrides = []
 #}
 
-class ms_header(Structure):
+class ms_scene_info(Structure):
 #{
-   _fields_ = [("version",c_uint32),
-               ("framerate",c_float),
-               ("index",array_file_meta)]
+   _fields_ = [("framerate",c_float)] 
 #}
 
 class ms_curve_keyframe(Structure):
@@ -431,6 +429,9 @@ def _sr_export_metascene( path ):
 
    _ms_compiler.strips.sort( key=lambda s: s.offset )
 
+   info = ms_scene_info()
+   info.framerate = bpy.context.scene.render.fps
+
    arrays = {
       'strings': _ms_compiler.strings.buffer,
       'ms_strip': _ms_compiler.strips,
@@ -438,12 +439,12 @@ def _sr_export_metascene( path ):
       'ms_keyframe': _ms_compiler.keyframes,
       'ms_curves': _ms_compiler.curve_keyframes,
       'ms_instance': _ms_compiler.instances,
-      'ms_override': _ms_compiler.overrides
+      'ms_override': _ms_compiler.overrides,
+      'ms_scene_info': [ info ]
    }
 
-   header = ms_header()
-   header.version = 1
-   header.framerate = bpy.context.scene.render.fps
+   header = array_file_header()
+   header.version = 2
    array_file_write( path, header, arrays )
 
    _ms_compiler.status = F"Written to {path}"

diff --git a/src/array_file.c b/src/array_file.c
index 6a50eb9923a0ddd0989a2b3b97f22b5f9a3545c0..b4c78409f1f1d5b20e6ad0f3128ca96f2a5093b7 100644 (file)
--- a/src/array_file.c
+++ b/src/array_file.c
@@ -1,4 +1,5 @@
 #include "array_file.h"
+#include <errno.h>
 
 const char *ps_get( array_file_ptr *strings, u32 pstr )
 {
@@ -16,20 +17,21 @@ bool ps_consteq( array_file_ptr *strings, u32 pstr, const char *str, u32 djb2 )
    else return 0;
 }
 
-static void af_load_array_file_buffer( FILE *fp, array_file_meta *arr, 
+static void af_load_array_file_buffer( array_file_context *ctx, 
+                                       array_file_meta *arr, 
                                        void *buffer, u32 stride )
 {
    if( arr->item_count )
    {
-      fseek( fp, arr->file_offset, SEEK_SET );
+      fseek( ctx->fp, arr->file_offset, SEEK_SET );
 
       if( stride == arr->item_size )
       {
-         u64 l = fread( buffer, arr->item_size*arr->item_count, 1, fp );
+         u64 l = fread( buffer, arr->item_size*arr->item_count, 1, ctx->fp );
          if( l != 1 ) 
          {
-            vg_file_error_info( fp );
-            fclose( fp );
+            vg_file_error_info( ctx->fp );
+            fclose( ctx->fp );
             vg_fatal_exit();
          }
       }
@@ -45,14 +47,14 @@ static void af_load_array_file_buffer( FILE *fp, array_file_meta *arr,
 
          for( u32 i=0; i<arr->item_count; i++ )
          {
-            u64 l = fread( buffer+i*stride, read_size, 1, fp );
+            u64 l = fread( buffer+i*stride, read_size, 1, ctx->fp );
             if( stride < arr->item_size )
-               fseek( fp, arr->item_size - stride, SEEK_CUR );
+               fseek( ctx->fp, arr->item_size - stride, SEEK_CUR );
 
             if( l != 1 ) 
             {
-               vg_file_error_info( fp );
-               fclose( fp );
+               vg_file_error_info( ctx->fp );
+               fclose( ctx->fp );
                vg_fatal_exit();
             }
          }
@@ -60,24 +62,23 @@ static void af_load_array_file_buffer( FILE *fp, array_file_meta *arr,
    }
 }
 
-void af_load_array_file( FILE *fp, array_file_ptr *ptr, 
-                         array_file_meta *arr, void *lin_alloc, 
-                         u32 stride )
+void af_load_array_file( array_file_context *ctx, array_file_ptr *out_ptr, 
+                         array_file_meta *arr, void *lin_alloc, u32 stride )
 {
    if( arr->item_count )
    {
       u32 size = stride*arr->item_count;
-      ptr->data = lin_alloc? vg_linear_alloc( lin_alloc, vg_align8(size) ):
-                             malloc( size );
-      af_load_array_file_buffer( fp, arr, ptr->data, stride );
+      out_ptr->data = lin_alloc? vg_linear_alloc( lin_alloc, vg_align8(size) ):
+                                 malloc( size );
+      af_load_array_file_buffer( ctx, arr, out_ptr->data, stride );
    }
    else
    {
-      ptr->data = NULL;
+      out_ptr->data = NULL;
    }
    
-   ptr->stride = stride;
-   ptr->count = arr->item_count;
+   out_ptr->stride = stride;
+   out_ptr->count = arr->item_count;
 }
 
 void *af_arritm( array_file_ptr *arr, u32 index )
@@ -90,11 +91,11 @@ u32 af_arrcount( array_file_ptr *arr )
    return arr->count;
 }
 
-array_file_meta *af_find_array( array_file_ptr *index, const char *name )
+array_file_meta *af_find_array( array_file_context *ctx, const char *name )
 {
-   for( u32 i=0; i<af_arrcount(index); i++ )
+   for( u32 i=0; i<af_arrcount(&ctx->index); i++ )
    {
-      array_file_meta *arr = af_arritm( index, i );
+      array_file_meta *arr = af_arritm( &ctx->index, i );
       
       if( !strncmp(arr->name,name,16) )
          return arr;
@@ -103,14 +104,14 @@ array_file_meta *af_find_array( array_file_ptr *index, const char *name )
    return NULL;
 }
 
-int af_load_array( FILE *fp, array_file_ptr *index, array_file_ptr *ptr,
+int af_load_array( array_file_context *ctx, array_file_ptr *ptr,
                    const char *name, void *lin_alloc, u32 stride )
 {
-   array_file_meta *arr = af_find_array( index, name );
+   array_file_meta *arr = af_find_array( ctx, name );
 
    if( arr )
    {
-      af_load_array_file( fp, ptr, arr, lin_alloc, stride );
+      af_load_array_file( ctx, ptr, arr, lin_alloc, stride );
       return 1;
    }
    else
@@ -121,3 +122,42 @@ int af_load_array( FILE *fp, array_file_ptr *index, array_file_ptr *ptr,
       return 0;
    }
 }
+
+void af_open( array_file_context *ctx, const char *path, 
+              u32 min_version, u32 max_version, void *lin_alloc )
+{
+   ctx->fp = fopen( path, "rb" );
+   if( !ctx->fp )
+   {
+      vg_fatal_condition();
+      vg_info( "open('%s'): %s\n", path, strerror(errno) );
+      vg_fatal_exit();
+   }
+
+   u64 l = fread( &ctx->header, sizeof(array_file_header), 1, ctx->fp );
+   if( l != 1 )
+   {
+      fclose( ctx->fp );
+      vg_fatal_error( "Array file corrupt\n" );
+   }
+
+   if( ctx->header.version < min_version || ctx->header.version > max_version )
+   {
+      vg_fatal_condition();
+      vg_info( "Legacy model version incompatable" );
+      vg_info( "For model: %s\n", path );
+      vg_info( "  version: %u (min: %u, max: %u)\n", 
+               ctx->header.version, min_version, max_version );
+      fclose( ctx->fp );
+      vg_fatal_exit();
+   }
+
+   af_load_array_file( ctx, &ctx->index, &ctx->header.index, lin_alloc,
+                       sizeof(array_file_meta) );
+}
+
+void af_close( array_file_context *ctx )
+{
+   fclose( ctx->fp );
+   ctx->fp = NULL;
+}

diff --git a/src/array_file.h b/src/array_file.h
index 1678541e35b44309c94ab9189a9b55805d9f3c14..892fa7503c4fb56bdfd137b81ad5903379f895ba 100644 (file)
--- a/src/array_file.h
+++ b/src/array_file.h
@@ -2,6 +2,8 @@
 
 typedef struct array_file_ptr array_file_ptr;
 typedef struct array_file_meta array_file_meta;
+typedef struct array_file_header array_file_header;
+typedef struct array_file_context array_file_context;
 
 struct array_file_ptr
 {
@@ -18,16 +20,33 @@ struct array_file_meta
    char name[16];
 };
 
+struct array_file_header
+{
+   u32 version;
+   array_file_meta index;
+};
+
+struct array_file_context
+{
+   FILE *fp;
+   array_file_header header;
+   array_file_ptr index;
+};
+
+void af_open( array_file_context *ctx, const char *path, 
+              u32 min_version, u32 max_version, void *lin_alloc );
+void af_close( array_file_context *ctx );
+
 /* array loading */
-array_file_meta *af_find_array( array_file_ptr *index, const char *name );
-void af_load_array_file( FILE *fp, array_file_ptr *ptr, 
+array_file_meta *af_find_array( array_file_context *ctx, const char *name );
+void af_load_array_file( array_file_context *ctx, array_file_ptr *out_ptr, 
                          array_file_meta *arr, void *lin_alloc, 
                          u32 stride );
-int af_load_array( FILE *fp, array_file_ptr *index, array_file_ptr *ptr,
+int af_load_array( array_file_context *ctx, array_file_ptr *ptr,
                    const char *name, void *lin_alloc, u32 stride );
 
-#define AF_LOAD_ARRAY_STRUCT( FP, INDEX, PTR, STRUCT, ALLOCATOR ) \
-   af_load_array( FP, INDEX, PTR, #STRUCT, ALLOCATOR, sizeof(STRUCT) )
+#define AF_LOAD_ARRAY_STRUCT( CTX, PTR, STRUCT, ALLOCATOR ) \
+   af_load_array( CTX, PTR, #STRUCT, ALLOCATOR, sizeof(STRUCT) )
 
 /* array access */
 void *af_arritm( array_file_ptr *arr, u32 index );

diff --git a/src/ent_region.c b/src/ent_region.c
index 91fd1aa078baf1ff7a2e913cfba4ffd70d30c600..3b178bfaf26431645191aa85aecf648b66214f0a 100644 (file)
--- a/src/ent_region.c
+++ b/src/ent_region.c
@@ -130,7 +130,7 @@ void ent_region_re_eval( world_instance *world )
       world_total &= combined;
 
       /* run unlock triggers. v105+ */
-      if( world->meta.info.version >= 105 ){
+      if( world->meta.version >= 105 ){
          if( region->flags & (k_ent_route_flag_achieve_gold|
                               k_ent_route_flag_achieve_silver) ){
             if( region->target0[0] ){

diff --git a/src/ent_route.c b/src/ent_route.c
index 5cf48467e924406b3e3badbe3bf5a591a145fe5e..141adbdc254b3fe9566f1d445fa95468d292313e 100644 (file)
--- a/src/ent_route.c
+++ b/src/ent_route.c
@@ -47,7 +47,7 @@ void ent_route_preupdate( ent_focus_context *ctx )
 
    u32 cam_id = 0;
    
-   if( __builtin_expect( world->meta.info.version >= 103, 1 ) )
+   if( __builtin_expect( world->meta.version >= 103, 1 ) )
       cam_id = route->id_camera;
 
    world_entity_focus_camera( world, cam_id );

diff --git a/src/font.h b/src/font.h
index 98142c08bc4b47ec40f899e3f02f4ec5f8cc080e..913ba40bfec15ec69c6fcc804d672657f3426712 100644 (file)
--- a/src/font.h
+++ b/src/font.h
@@ -87,11 +87,12 @@ static void font3d_load( font3d *font, const char *mdl_path, void *alloc )
 
    vg_linear_clear( vg_mem.scratch );
    array_file_ptr fonts;
-   MDL_LOAD_ARRAY_STRUCT( mdl, &fonts, ent_font, vg_mem.scratch );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &fonts, ent_font, vg_mem.scratch );
    font->info = *((ent_font *)af_arritm(&fonts,0));
 
-   MDL_LOAD_ARRAY_STRUCT( mdl, &font->font_variants, ent_font_variant, alloc);
-   MDL_LOAD_ARRAY_STRUCT( mdl, &font->glyphs, ent_glyph, alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &font->font_variants, 
+                                    ent_font_variant, alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &font->glyphs, ent_glyph, alloc );
 
    vg_linear_clear( vg_mem.scratch );
 

diff --git a/src/metascene.c b/src/metascene.c
index 7c7c92cf37ac9799862ca28ec732fd57e67d9317..91749af6f06091286ebb8061c90de40dd7811dec 100644 (file)
--- a/src/metascene.c
+++ b/src/metascene.c
@@ -2,46 +2,27 @@
 
 void metascene_load( ms_context *ms, const char *path, void *alloc )
 {
-   memset( ms, 0, sizeof( ms_context ) );
-   FILE *fp = fopen( path, "rb" );
-
-   if( !fp )
-   {
-      vg_fatal_condition();
-      vg_info( "metascene_load( '%s' ): %s\n", path, strerror(errno) );
-      vg_fatal_exit();
-   }
-
-   u64 l = fread( &ms->info, sizeof(ms_header), 1, fp );
-   if( l != 1 )
+   af_open( &ms->af, path, MS_VERSION_MIN, MS_VERSION_NR, alloc );
+   af_load_array( &ms->af, &ms->strings, "strings", alloc, 1 );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->infos, ms_scene_info, alloc );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->instances, ms_instance, alloc );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->overrides, ms_override, alloc );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->strips, ms_strip, alloc );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->tracks, ms_track, alloc );
+   AF_LOAD_ARRAY_STRUCT( &ms->af, &ms->keyframes, ms_keyframe, alloc );
+   af_load_array( &ms->af, &ms->curves, "ms_curves", 
+                   alloc, sizeof(ms_curve_keyframe) );
+   af_close( &ms->af );
+
+   if( af_arrcount( &ms->infos ) )
    {
-      vg_fatal_condition();
-      vg_info( "Read corruption error" );
-      vg_fatal_exit();
+      ms_scene_info *src_inf = af_arritm( &ms->infos, 0 );
+      ms->info = *src_inf;
    }
-
-   if( ms->info.version < MS_VERSION_MIN )
+   else
    {
-      vg_fatal_condition();
-      vg_info( "Legacy metascene version incompatable" );
-      vg_info( "For file: %s\n", path );
-      vg_info( " version: %u (min: %u, current: %u)\n", 
-               ms->info.version, MS_VERSION_MIN, MS_VERSION_NR );
-      vg_fatal_exit();
+      vg_fatal_error( "No scene info in metascene.\n" );
    }
-
-   af_load_array_file( fp, &ms->index, &ms->info.index, alloc,
-                       sizeof(array_file_meta) );
-
-   af_load_array( fp, &ms->index, &ms->strings, "strings", alloc, 1 );
-   AF_LOAD_ARRAY_STRUCT( fp, &ms->index, &ms->instances, ms_instance, alloc );
-   AF_LOAD_ARRAY_STRUCT( fp, &ms->index, &ms->overrides, ms_override, alloc );
-   AF_LOAD_ARRAY_STRUCT( fp, &ms->index, &ms->strips, ms_strip, alloc );
-   AF_LOAD_ARRAY_STRUCT( fp, &ms->index, &ms->tracks, ms_track, alloc );
-   AF_LOAD_ARRAY_STRUCT( fp, &ms->index, &ms->keyframes, ms_keyframe, alloc );
-   af_load_array( fp, &ms->index, &ms->curves, "ms_curves", 
-                     alloc, sizeof(ms_curve_keyframe) );
-   fclose( fp );
 }
 
 struct

diff --git a/src/metascene.h b/src/metascene.h
index f95eedc205955002e9ef772c02483300726d8eff..ca3aa36745438585eae23ce514cb70a6ef56c9d4 100644 (file)
--- a/src/metascene.h
+++ b/src/metascene.h
@@ -2,11 +2,11 @@
 #include "model.h"
 #include "world.h"
 
-#define MS_VERSION_NR 1
-#define MS_VERSION_MIN 1
+#define MS_VERSION_NR 2
+#define MS_VERSION_MIN 2
 
+typedef struct ms_scene_info ms_scene_info;
 typedef struct ms_context ms_context;
-typedef struct ms_header ms_header;
 typedef struct ms_instance ms_instance;
 typedef struct ms_override ms_override;
 typedef struct ms_strip ms_strip;
@@ -14,19 +14,19 @@ typedef struct ms_track ms_track;
 typedef struct ms_curve_keyframe ms_curve_keyframe;
 typedef struct mdl_transform ms_keyframe;
 
-struct ms_header
+struct ms_scene_info
 {
-   u32 version;
    f32 framerate;
-   array_file_meta index;
 };
 
 struct ms_context
 {
-   ms_header info;
-   struct array_file_ptr index,
-                         strings,
+   array_file_context af;
 
+   ms_scene_info info;
+   struct array_file_ptr strings,
+                         
+                         infos,
                          instances,
                          overrides,
                          strips,

diff --git a/src/model.c b/src/model.c
index e49309650a8fb4f3f333baa174245d05f7801648..5f1af40964be2dd9b48750b263aa557323baabbc 100644 (file)
--- a/src/model.c
+++ b/src/model.c
@@ -20,14 +20,6 @@
 #include "shader_props.h"
 #include "array_file.h"
 
-static void mdl_load_fatal_corrupt( mdl_context *mdl )
-{
-   vg_fatal_condition();
-   vg_file_error_info( mdl->file );
-   fclose( mdl->file );
-   vg_fatal_exit();
-}
-
 /*
  * Model implementation
  */
@@ -42,37 +34,31 @@ void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst )
       vg_fatal_exit();
    }
 
-   fseek( mdl->file, mdl->pack_base_offset+info->pack_offset, SEEK_SET );
-   u64 l = fread( dst, info->pack_size, 1, mdl->file );
+   fseek( mdl->af.fp, mdl->pack_base_offset+info->pack_offset, SEEK_SET );
+   u64 l = fread( dst, info->pack_size, 1, mdl->af.fp );
 
-   if( l != 1 ) mdl_load_fatal_corrupt( mdl );
-}
-
-int mdl_load_array( mdl_context *mdl, array_file_ptr *ptr, const char *name,
-                    void *lin_alloc, u32 stride )
-{
-   return af_load_array( mdl->file, &mdl->index, ptr, name, lin_alloc, stride );
+   if( l != 1 )
+   {
+      af_close( &mdl->af );
+      vg_fatal_error( "Pack data corruption\n" );
+   }
 }
 
-int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
+void mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
 {
-   int s = 1;
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->verts,    mdl_vert,   lin_alloc );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->indices,  mdl_indice, lin_alloc );
-   return s;
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->verts,    mdl_vert,   lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->indices,  mdl_indice, lin_alloc );
 }
 
-int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
+void mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
 {
-   int s = 1;
-   s &= mdl_load_array       ( mdl, &mdl->strings, "strings", lin_alloc, 1 );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->meshs,     mdl_mesh,     lin_alloc );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->submeshs,  mdl_submesh,  lin_alloc );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->textures,  mdl_texture,  lin_alloc );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->armatures, mdl_armature, lin_alloc );
-   s &= MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->bones,     mdl_bone,     lin_alloc );
-   s &= mdl_load_materials( mdl, lin_alloc );
-   return s;
+   af_load_array       ( &mdl->af, &mdl->strings, "strings", lin_alloc, 1 );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->meshs,     mdl_mesh,     lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->submeshs,  mdl_submesh,  lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->textures,  mdl_texture,  lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->armatures, mdl_armature, lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->bones,     mdl_bone,     lin_alloc );
+   mdl_load_materials( mdl, lin_alloc );
 }
 
 void *mdl_shader_standard( vg_msg *msg, void *alloc )
@@ -174,25 +160,25 @@ static bool mdl_legacy_v105_properties( struct mdl_material_v105 *mat,
    return 1;
 }
 
-int mdl_load_materials( mdl_context *mdl, void *lin_alloc )
+void mdl_load_materials( mdl_context *mdl, void *lin_alloc )
 {
-   MDL_LOAD_ARRAY_STRUCT( mdl, &mdl->materials, mdl_material, lin_alloc );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->materials, mdl_material, lin_alloc );
 
 #if (MDL_VERSION_MIN <= 105)
    /* load legacy material data into scratch */
    array_file_ptr legacy_materials;
-   if( mdl->info.version <= 105 )
+   if( mdl->version <= 105 )
    {
-      mdl_load_array( mdl, &legacy_materials, "mdl_material", vg_mem.scratch,
-                      sizeof(struct mdl_material_v105) );
+      af_load_array( &mdl->af, &legacy_materials, "mdl_material", 
+                      vg_mem.scratch, sizeof(struct mdl_material_v105) );
    }
 #endif
 
    array_file_ptr data;
-   mdl_load_array( mdl, &data, "shader_data", vg_mem.scratch, 1 );
+   af_load_array( &mdl->af, &data, "shader_data", vg_mem.scratch, 1 );
 
    if( !lin_alloc )
-      return 1;
+      return;
 
    for( u32 i=0; i<af_arrcount(&mdl->materials); i ++ )
    {
@@ -201,7 +187,7 @@ int mdl_load_materials( mdl_context *mdl, void *lin_alloc )
 
 #if (MDL_VERSION_MIN <= 105)
       u8 legacy_buf[512];
-      if( mdl->info.version <= 105 )
+      if( mdl->version <= 105 )
       {
          vg_msg_init( &msg, legacy_buf, sizeof(legacy_buf) );
          mdl_legacy_v105_properties( af_arritm( &legacy_materials,i ), &msg );
@@ -240,8 +226,6 @@ int mdl_load_materials( mdl_context *mdl, void *lin_alloc )
       else
          mat->props.compiled = NULL;
    }
-
-   return 1;
 }
 
 /*
@@ -250,33 +234,10 @@ int mdl_load_materials( mdl_context *mdl, void *lin_alloc )
 void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
 {
    memset( mdl, 0, sizeof( mdl_context ) );
-   mdl->file = fopen( path, "rb" );
-
-   if( !mdl->file )
-   {
-      vg_fatal_condition();
-      vg_info( "mdl_open('%s'): %s\n", path, strerror(errno) );
-      vg_fatal_exit();
-   }
-
-   u64 l = fread( &mdl->info, sizeof(mdl_header), 1, mdl->file );
-   if( l != 1 )
-      mdl_load_fatal_corrupt( mdl );
-
-   if( mdl->info.version < MDL_VERSION_MIN )
-   {
-      vg_fatal_condition();
-      vg_info( "Legacy model version incompatable" );
-      vg_info( "For model: %s\n", path );
-      vg_info( "  version: %u (min: %u, current: %u)\n", 
-               mdl->info.version, MDL_VERSION_MIN, MDL_VERSION_NR );
-      vg_fatal_exit();
-   }
-
-   af_load_array_file( mdl->file, &mdl->index, &mdl->info.index, lin_alloc,
-                       sizeof(array_file_meta) );
+   af_open( &mdl->af, path, MDL_VERSION_MIN, MDL_VERSION_NR, lin_alloc );
+   mdl->version = mdl->af.header.version;
 
-   array_file_meta *pack = af_find_array( &mdl->index, "pack" );
+   array_file_meta *pack = af_find_array( &mdl->af, "pack" );
    if( pack ) mdl->pack_base_offset = pack->file_offset;
    else mdl->pack_base_offset = 0;
 }
@@ -286,8 +247,7 @@ void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
  */
 void mdl_close( mdl_context *mdl )
 {
-   fclose( mdl->file );
-   mdl->file = NULL;
+   af_close( &mdl->af );
 }
 
 /* useful things you can do with the model */
@@ -435,8 +395,8 @@ static void _sync_mdl_load_glmesh( void *payload, u32 size )
 
 void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh, u32 *fixup_table )
 {
-   array_file_meta *arr_vertices = af_find_array( &mdl->index, "mdl_vert" );
-   array_file_meta *arr_indices = af_find_array( &mdl->index, "mdl_indice" );
+   array_file_meta *arr_vertices = af_find_array( &mdl->af, "mdl_vert" );
+   array_file_meta *arr_indices = af_find_array( &mdl->af, "mdl_indice" );
 
    if( arr_vertices && arr_indices )
    {
@@ -456,9 +416,9 @@ void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh, u32 *fixup_table )
       job->vertex_count = arr_vertices->item_count;
       job->indice_count = arr_indices->item_count;
 
-      af_load_array_file_buffer( mdl->file, arr_vertices, 
+      af_load_array_file_buffer( &mdl->af, arr_vertices, 
                                   job->verts, sizeof(mdl_vert) );
-      af_load_array_file_buffer( mdl->file, arr_indices, job->indices, 
+      af_load_array_file_buffer( &mdl->af, arr_indices, job->indices, 
                                   sizeof(mdl_indice) );
 
       if( fixup_table )

diff --git a/src/model.h b/src/model.h
index b706482b6872db57f16be90084f046fc605e34c7..2bcb52c0ae798bd5e86dca1bbcc9ebe5b68799bd 100644 (file)
--- a/src/model.h
+++ b/src/model.h
@@ -248,18 +248,12 @@ struct mdl_texture
    u32 glname;
 };
 
-struct mdl_header
-{
-   u32 version;
-   array_file_meta index;
-};
-
 struct mdl_context
 {
-   FILE *file;
-   mdl_header info;
+   array_file_context af;
+   u32 version;
 
-   struct array_file_ptr index,
+   struct array_file_ptr 
 
    /* metadata */
    strings,
@@ -273,6 +267,7 @@ struct mdl_context
    /* mesh buffers */
    verts,
    indices;
+
    u32 pack_base_offset;
 
    /* runtime */
@@ -288,19 +283,13 @@ void mesh_free( glmesh *mesh );
 void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc );
 void mdl_close( mdl_context *mdl );
 
-int mdl_load_array( mdl_context *mdl, array_file_ptr *ptr, const char *name,
-                    void *lin_alloc, u32 stride );
-
-#define MDL_LOAD_ARRAY_STRUCT( MDL, PTR, STRUCT, ALLOCATOR ) \
-   mdl_load_array( MDL, PTR, #STRUCT, ALLOCATOR, sizeof(STRUCT) )
-
 /* pack access */
 void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst );
 
 /* standard array groups */
-int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc );
-int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc );
-int mdl_load_materials( mdl_context *mdl, void *lin_alloc );
+void mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc );
+void mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc );
+void mdl_load_materials( mdl_context *mdl, void *lin_alloc );
 
 /* load mesh */
 void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh, u32 *fixup_table );

diff --git a/src/player_glide.c b/src/player_glide.c
index 8eea9106f7b3db8b2451fb099a656652f64b777d..fff01ed191a654ec4dd35e89f9bf3591d9c1b893 100644 (file)
--- a/src/player_glide.c
+++ b/src/player_glide.c
@@ -460,7 +460,7 @@ void player_glide_bind(void)
 
    /* load trail positions */
    array_file_ptr markers;
-   MDL_LOAD_ARRAY_STRUCT( mdl, &markers, ent_marker, vg_mem.scratch );
+   AF_LOAD_ARRAY_STRUCT( &mdl->af, &markers, ent_marker, vg_mem.scratch );
    mdl_close( mdl );
 
    for( u32 i=0; i<af_arrcount( &markers ); i ++ )

diff --git a/src/player_render.c b/src/player_render.c
index 31346d7a72fc2cb9354e87d923bf49977f515b55..f6725d1c17504bf9999c0707054fba42ea07dc10 100644 (file)
--- a/src/player_render.c
+++ b/src/player_render.c
@@ -153,7 +153,7 @@ void player_board_load( struct player_board *board, const char *path )
    dynamic_model_load( &ctx, &board->mdl, path, NULL );
 
    array_file_ptr markers;
-   MDL_LOAD_ARRAY_STRUCT( &ctx, &markers, ent_marker, vg_mem.scratch );
+   AF_LOAD_ARRAY_STRUCT( &ctx.af, &markers, ent_marker, vg_mem.scratch );
 
    /* TODO: you get put into a new section, the above is standard mdl loads. */
    for( int i=0; i<4; i++ )

diff --git a/src/world_gate.c b/src/world_gate.c
index ad8c73850ca8b1bdc0edce34ff666519ba130840..891cf710fd21264c29cbddc4fe1bfeb8718a8b0b 100644 (file)
--- a/src/world_gate.c
+++ b/src/world_gate.c
@@ -384,7 +384,7 @@ void world_link_gates_async( void *payload, u32 size )
             v4_copy( gate->q[0], gate2->q[1] );
             v4_copy( gate2->q[0], gate->q[1] );
 
-            if( world->meta.info.version < 102 ){
+            if( world->meta.version < 102 ){
                /* LEGACY BEHAVIOUR: v101
                 *   this would flip both the client worlds portal's entrance and
                 *   exit. effectively the clients portal would be the opposite 

diff --git a/src/world_load.c b/src/world_load.c
index cb473d8edccaf400c040b61da93652c2cb1d2943..efa51367fa2d96911184dcf9d381d0fcea68c667 100644 (file)
--- a/src/world_load.c
+++ b/src/world_load.c
@@ -37,6 +37,7 @@ static void world_instance_load_mdl( u32 instance_id, const char *path ){
 
    world->heap = heap;
    mdl_context *meta = &world->meta;
+   array_file_context *af = &meta->af;
 
    mdl_open( meta, path, world->heap );
    mdl_load_metadata_block( meta, world->heap );
@@ -44,42 +45,42 @@ static void world_instance_load_mdl( u32 instance_id, const char *path ){
 
    vg_info( "%u\n", sizeof(ent_cubemap) );
 
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_gate,      ent_gate,       heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_camera,    ent_camera,     heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_spawn,     ent_spawn,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_light,     ent_light,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_route_node,ent_route_node, heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_path_index,ent_path_index, heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_checkpoint,ent_checkpoint, heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_route,     ent_route,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_water,     ent_water,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_audio_clip,ent_audio_clip, heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_audio,     ent_audio,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_volume,    ent_volume,     heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_traffic,   ent_traffic,    heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_marker,    ent_marker,     heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_skateshop, ent_skateshop,  heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_swspreview,ent_swspreview, heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_ccmd,      ent_ccmd,       heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_objective, ent_objective,  heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_challenge, ent_challenge,  heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_relay,     ent_relay,      heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_cubemap,   ent_cubemap,    heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_miniworld, ent_miniworld,  heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_prop,      ent_prop,       heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_region,    ent_region,     heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_glider,    ent_glider,     heap );
-   MDL_LOAD_ARRAY_STRUCT( meta, &world->ent_npc,       ent_npc,        heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_gate,      ent_gate,       heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_camera,    ent_camera,     heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_spawn,     ent_spawn,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_light,     ent_light,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_route_node,ent_route_node, heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_path_index,ent_path_index, heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_checkpoint,ent_checkpoint, heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_route,     ent_route,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_water,     ent_water,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_audio_clip,ent_audio_clip, heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_audio,     ent_audio,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_volume,    ent_volume,     heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_traffic,   ent_traffic,    heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_marker,    ent_marker,     heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_skateshop, ent_skateshop,  heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_swspreview,ent_swspreview, heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_ccmd,      ent_ccmd,       heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_objective, ent_objective,  heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_challenge, ent_challenge,  heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_relay,     ent_relay,      heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_cubemap,   ent_cubemap,    heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_miniworld, ent_miniworld,  heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_prop,      ent_prop,       heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_region,    ent_region,     heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_glider,    ent_glider,     heap );
+   AF_LOAD_ARRAY_STRUCT( af, &world->ent_npc,       ent_npc,        heap );
 
    array_file_ptr infos;
-   MDL_LOAD_ARRAY_STRUCT( meta, &infos, ent_worldinfo, vg_mem.scratch );
+   AF_LOAD_ARRAY_STRUCT( af, &infos, ent_worldinfo, vg_mem.scratch );
 
    world->skybox = k_skybox_default;
    if( af_arrcount(&infos) )
    {
       world->info = *((ent_worldinfo *)af_arritm(&infos,0));
 
-      if( world->meta.info.version >= 104 )
+      if( world->meta.version >= 104 )
       {
          if( PS_EQ( &world->meta.strings, world->info.pstr_skybox, "space" ))
          {

diff --git a/src/world_volumes.c b/src/world_volumes.c
index ceb154182e9129485ae6b706e6a67fb51141ff6b..21234898a5a914c82e190cbd3f0df6b433583d01 100644 (file)
--- a/src/world_volumes.c
+++ b/src/world_volumes.c
@@ -22,7 +22,7 @@ void world_volumes_update( world_instance *world, v3f pos )
          /* 
           * LEGACY BEHAVIOUR: < v104 does not have leave events
           */
-         if( world->meta.info.version >= 104 ){
+         if( world->meta.version >= 104 ){
             ent_call basecall;
             basecall.function = k_ent_function_trigger_leave;
             basecall.id = mdl_entity_id( k_ent_volume, idx );