X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=addon.c;h=ee3f803392a964795bf96f6615bf32f8f105a251;hb=ca35eceae3abfcfb9ba266d6ea8e664bc06b0a3e;hp=fe6693f89adf847a9f4bfad27c057d660eef7337;hpb=4a567dd9ef3bd63fb924d80fd2e09323b99d0a34;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/addon.c b/addon.c
index fe6693f..ee3f803 100644
--- a/addon.c
+++ b/addon.c
@@ -2,23 +2,21 @@
 #define ADDON_C
 
 #include "addon.h"
+#include "addon_types.h"
 #include "vg/vg_msg.h"
 #include "steam.h"
-#include "workshop_types.h"
 #include "workshop.h"
 
-#include "addon_cache.c"
-
-static u32 addon_count( enum workshop_file_type type ){
+static u32 addon_count( enum addon_type type ){
    return addon_system.registry_type_counts[ type ];
 }
 
 /* these kind of suck, oh well. */
-static addon_reg *get_addon_from_index(enum workshop_file_type type, u32 index){
+static addon_reg *get_addon_from_index(enum addon_type type, u32 index){
    u32 count = 0;
    for( u32 i=0; count<addon_count(type); i++ ){
       addon_reg *reg = &addon_system.registry[i];
-      if( reg->type == type ){
+      if( reg->alias.type == type ){
          if( index == count )
             return reg;
 
@@ -29,11 +27,11 @@ static addon_reg *get_addon_from_index(enum workshop_file_type type, u32 index){
    return NULL;
 }
 
-static u32 get_index_from_addon( enum workshop_file_type type, addon_reg *a ){
+static u32 get_index_from_addon( enum addon_type type, addon_reg *a ){
    u32 count = 0;
    for( u32 i=0; count<addon_system.registry_type_counts[type]; i++ ){
       addon_reg *reg = &addon_system.registry[i];
-      if( reg->type == type ){
+      if( reg->alias.type == type ){
          if( reg == a )
             return count;
 
@@ -44,22 +42,21 @@ static u32 get_index_from_addon( enum workshop_file_type type, addon_reg *a ){
    return 0xffffffff;
 }
 
-static u32 addon_match( enum workshop_file_type type,
-                        u64 workshop_id, const char *foldername ){
-   u32 foldername_djb2 = vg_strdjb2( foldername );
+static u32 addon_match( addon_alias *alias ){
+   u32 foldername_djb2 = vg_strdjb2( alias->foldername );
 
    u32 count = 0;
-   for( u32 i=0; count<addon_system.registry_type_counts[type]; i++ ){
+   for( u32 i=0; count<addon_system.registry_type_counts[alias->type]; i++ ){
       addon_reg *reg = &addon_system.registry[i];
-      if( reg->type == type ){
+      if( reg->alias.type == alias->type ){
          
-         if( workshop_id ){
-            if( workshop_id == reg->workshop_id )
+         if( alias->workshop_id ){
+            if( alias->workshop_id == reg->alias.workshop_id )
                return count;
          }
          else{
             if( reg->foldername_hash == foldername_djb2 ){
-               if( !strcmp( reg->foldername, foldername ) ){
+               if( !strcmp( reg->alias.foldername, alias->foldername ) ){
                   return count;
                }
             }
@@ -75,6 +72,36 @@ static u32 addon_match( enum workshop_file_type type,
 static void addon_system_init( void ){
    u32 reg_size   = sizeof(addon_reg)*ADDON_MOUNTED_MAX;
    addon_system.registry = vg_linear_alloc( vg_mem.rtmemory, reg_size );
+
+   for( u32 type=0; type<k_addon_type_max; type++ ){
+      struct addon_type_info *inf = &addon_type_infos[type];
+      struct addon_cache *cache = &addon_system.cache[type];
+
+      if( inf->cache_count ){
+         /* create the allocations pool */
+         u32 alloc_size = sizeof(struct addon_cache_entry)*inf->cache_count;
+         cache->allocs = vg_linear_alloc( vg_mem.rtmemory, alloc_size );
+         memset( cache->allocs, 0, alloc_size );
+
+         cache->pool.buffer = cache->allocs;
+         cache->pool.count  = inf->cache_count;
+         cache->pool.stride = sizeof( struct addon_cache_entry );
+         cache->pool.offset = offsetof( struct addon_cache_entry, poolnode );
+         vg_pool_init( &cache->pool );
+
+         /* create the real memory */
+         u32 cache_size = inf->cache_stride*inf->cache_count;
+         cache->items = vg_linear_alloc( vg_mem.rtmemory, cache_size );
+         cache->stride = inf->cache_stride;
+         memset( cache->items, 0, cache_size );
+
+         for( i32 j=0; j<inf->cache_count; j++ ){
+            struct addon_cache_entry *alloc = &cache->allocs[j];
+            alloc->reg_ptr   = NULL;
+            alloc->reg_index = 0xffffffff;
+         }
+      }
+   }
 }
 
 /*
@@ -89,25 +116,26 @@ VG_STATIC void async_addon_reg_update( void *data, u32 size )
 {
    vg_info( "Registry update notify\n" );
    
-   for( u32 i=0; i<k_workshop_file_type_max; i++ ){
+   for( u32 i=0; i<k_addon_type_max; i++ ){
       addon_system.registry_type_counts[i] = 0;
    }
 
    for( u32 i=0; i<addon_system.registry_count; i++ ){
-      addon_system.registry_type_counts[ addon_system.registry[i].type ] ++;
+      enum addon_type type = addon_system.registry[i].alias.type;
+      addon_system.registry_type_counts[ type ] ++;
    }
 }
 
 VG_STATIC void addon_set_foldername( addon_reg *reg, const char name[64] ){
-   vg_strncpy( name, reg->foldername, 64, k_strncpy_always_add_null );
-   reg->foldername_hash = vg_strdjb2( reg->foldername );
+   vg_strncpy( name, reg->alias.foldername, 64, k_strncpy_always_add_null );
+   reg->foldername_hash = vg_strdjb2( reg->alias.foldername );
 }
 
 /*
  * Create a new registry 
  */
 VG_STATIC addon_reg *addon_alloc_reg( PublishedFileId_t workshop_id,
-                                      enum workshop_file_type type ){
+                                      enum addon_type type ){
    if( addon_system.registry_count == ADDON_MOUNTED_MAX ){
       vg_error( "You have too many addons installed!\n" );
       return NULL;
@@ -115,11 +143,11 @@ VG_STATIC addon_reg *addon_alloc_reg( PublishedFileId_t workshop_id,
 
    addon_reg *reg = &addon_system.registry[ addon_system.registry_count ];
    reg->metadata_len = 0;
-   reg->userdata = NULL;
+   reg->cache_id = 0;
    reg->state = k_addon_state_indexed;
-   reg->workshop_id = workshop_id;
-   reg->foldername[0] = '\0';
-   reg->type = type;
+   reg->alias.workshop_id = workshop_id;
+   reg->alias.foldername[0] = '\0';
+   reg->alias.type = type;
 
    if( workshop_id ){
       char foldername[64];
@@ -161,15 +189,16 @@ VG_STATIC int addon_try_load_metadata( addon_reg *reg, vg_str folder_path ){
 
 VG_STATIC void addon_print_info( addon_reg *reg ){
    vg_info( "addon_reg #%u{\n", addon_system.registry_count );
-   vg_info( "  type: %d\n", reg->type );
-   vg_info( "  workshop_id: " PRINTF_U64 "\n", reg->workshop_id );
-   vg_info( "  folder: [%u]%s\n", reg->foldername_hash, reg->foldername );
+   vg_info( "  type: %d\n", reg->alias.type );
+   vg_info( "  workshop_id: " PRINTF_U64 "\n", reg->alias.workshop_id );
+   vg_info( "  folder: [%u]%s\n", reg->foldername_hash, reg->alias.foldername );
    vg_info( "  metadata_len: %u\n", reg->metadata_len );
-   vg_info( "  userdata: %p\n", reg->userdata );
+   vg_info( "  cache_id: %hu\n", reg->cache_id );
    vg_info( "}\n" );
 }
 
 VG_STATIC void addon_mount_finish( addon_reg *reg ){
+   addon_print_info( reg );
    addon_system.registry_count ++;
 }
 
@@ -179,14 +208,14 @@ VG_STATIC void addon_mount_finish( addon_reg *reg ){
 VG_STATIC addon_reg *addon_mount_workshop_folder( PublishedFileId_t workshop_id,
                                                   vg_str folder_path )
 {
-   addon_reg *reg = addon_alloc_reg( workshop_id, k_workshop_file_type_none );
+   addon_reg *reg = addon_alloc_reg( workshop_id, k_addon_type_none );
    if( !reg ) return NULL;
 
    if( !addon_try_load_metadata( reg, folder_path ) ){
       return NULL;
    }
 
-   enum workshop_file_type type = k_workshop_file_type_none;
+   enum addon_type type = k_addon_type_none;
    vg_msg root = {0};
    root.buf = reg->metadata;
    root.len = reg->metadata_len;
@@ -197,12 +226,12 @@ VG_STATIC addon_reg *addon_mount_workshop_folder( PublishedFileId_t workshop_id,
       type = vg_msg_seekkvu32( &workshop, "type", k_vg_msg_first );
    }
 
-   if( type == k_workshop_file_type_none ){
+   if( type == k_addon_type_none ){
       vg_error( "Cannot determine addon type\n" );
       return NULL;
    }
 
-   reg->type = type;
+   reg->alias.type = type;
    addon_mount_finish( reg );
    return reg;
 }
@@ -211,7 +240,7 @@ VG_STATIC addon_reg *addon_mount_workshop_folder( PublishedFileId_t workshop_id,
  * Mount a local folder. may or may not have addon.inf
  */
 VG_STATIC addon_reg *addon_mount_local_addon( const char *folder,
-                                              enum workshop_file_type type,
+                                              enum addon_type type,
                                               const char *content_ext )
 {
    char folder_path_buf[4096];
@@ -224,8 +253,8 @@ VG_STATIC addon_reg *addon_mount_local_addon( const char *folder,
    for( u32 i=0; i<addon_system.registry_count; i++ ){
       addon_reg *reg = &addon_system.registry[i];
 
-      if( (reg->type == type) && (reg->foldername_hash == folder_hash) ){
-         if( !strcmp( reg->foldername, folder_name ) ){
+      if( (reg->alias.type == type) && (reg->foldername_hash == folder_hash) ){
+         if( !strcmp( reg->alias.foldername, folder_name ) ){
             reg->state = k_addon_state_indexed;
             return NULL;
          }
@@ -313,7 +342,7 @@ VG_STATIC void addon_mount_workshop_items(void){
       for( u32 i=0; i<addon_system.registry_count; i++ ){
          addon_reg *reg = &addon_system.registry[i];
 
-         if( reg->workshop_id == id ){
+         if( reg->alias.workshop_id == id ){
             reg->state = k_addon_state_indexed;
             goto next_file_workshop;
          }
@@ -341,7 +370,7 @@ next_file_workshop:;
  * Scan a local content folder for addons. It must find at least one file with 
  * the specified content_ext to be considered.
  */
-VG_STATIC void addon_mount_content_folder( enum workshop_file_type type,
+VG_STATIC void addon_mount_content_folder( enum addon_type type,
                                            const char *base_folder, 
                                            const char *content_ext )
 {
@@ -356,7 +385,6 @@ VG_STATIC void addon_mount_content_folder( enum workshop_file_type type,
    vg_dir dir;
    if( !vg_dir_open(&dir,path.buffer) ){
       vg_error( "vg_dir_open('%s') failed\n", path.buffer );
-      vg_async_call( workshop_async_any_complete, NULL, 0 );
       return;
    }
 
@@ -381,19 +409,22 @@ VG_STATIC void addon_mount_content_folder( enum workshop_file_type type,
    vg_dir_close(&dir);
 }
 
+/*
+ * write the full path of the addon's folder into the vg_str
+ */
 static int addon_get_content_folder( addon_reg *reg, vg_str *folder ){
-   if( reg->workshop_id ){
+   if( reg->alias.workshop_id ){
       vg_async_item *call = 
          vg_async_alloc( sizeof(struct async_workshop_filepath_info) );
       struct async_workshop_filepath_info *info = call->payload;
       info->buf = folder->buffer;
-      info->id = reg->workshop_id;
+      info->id = reg->alias.workshop_id;
       info->len = folder->len;
       vg_async_dispatch( call, async_workshop_get_filepath );
       vg_async_stall(); /* too bad! */
       if( info->buf[0] == '\0' ){
          vg_error( "Failed SteamAPI_GetItemInstallInfo(" PRINTF_U64 ")\n",
-                     reg->workshop_id );
+                     reg->alias.workshop_id );
          return 0;
       }
       folder->i = strlen( folder->buffer );
@@ -401,15 +432,253 @@ static int addon_get_content_folder( addon_reg *reg, vg_str *folder ){
    }
    else{
       folder->i = 0;
-      if( reg->type == k_workshop_file_type_board )
-         vg_strcat( folder, "boards/" );
-      else if( reg->type == k_workshop_file_type_world )
-         vg_strcat( folder, "maps/" );
-      else return 0;
+      
+      const char *local_folder = 
+         addon_type_infos[reg->alias.type].local_content_folder;
+
+      if( !local_folder ) return 0;
+      vg_strcat( folder, local_folder );
+      vg_strcat( folder, reg->alias.foldername );
+      return 1;
+   }
+}
+
+/*
+ * Return existing cache id if reg_index points to a registry with its cache
+ * already set.
+ */
+static u16 addon_cache_fetch( enum addon_type type, u32 reg_index ){
+   addon_reg *reg = NULL;
+
+   if( reg_index < addon_count( type ) ){
+      reg = get_addon_from_index( type, reg_index );
+      if( reg->cache_id ) 
+         return reg->cache_id;
+   }
+
+   return 0;
+}
+
+/*
+ * Allocate a new cache item from the pool
+ */
+static u16 addon_cache_alloc( enum addon_type type, u32 reg_index ){
+   struct addon_cache *cache = &addon_system.cache[ type ];
+
+   u16 new_id = vg_pool_lru( &cache->pool );
+   struct addon_cache_entry *new_entry = vg_pool_item( &cache->pool, new_id );
+
+   addon_reg *reg = NULL;
+   if( reg_index < addon_count( type ) )
+      reg = get_addon_from_index( type, reg_index );
+
+   if( new_entry ){
+      if( new_entry->reg_ptr )
+         new_entry->reg_ptr->cache_id = 0;
+
+      if( reg )
+         reg->cache_id = new_id;
+
+      new_entry->reg_ptr = reg;
+      new_entry->reg_index = reg_index;
+      return new_id;
+   }
+   else{
+      vg_error( "cache full (type: %u)!\n", type );
+      return 0;
+   }
+}
+
+/*
+ * Get the real item data for cache id 
+ */
+static void *addon_cache_item( enum addon_type type, u16 id ){
+   if( !id ) return NULL;
+
+   struct addon_cache *cache = &addon_system.cache[type];
+   return cache->items + ((size_t)(id-1) * cache->stride);
+}
+
+/*
+ * Get the real item data for cache id ONLY if the item is completely loaded.
+ */
+static void *addon_cache_item_if_loaded( enum addon_type type, u16 id ){
+   if( !id ) return NULL;
+
+   struct addon_cache *cache = &addon_system.cache[type];
+   struct addon_cache_entry *entry = vg_pool_item( &cache->pool, id );
+
+   if( entry->state == k_addon_cache_state_loaded )
+      return addon_cache_item( type, id );
+   else return NULL;
+}
+
+/* 
+ * Updates the item state from the main thread
+ */
+static void async_addon_setstate( void *_entry, u32 _state ){
+   addon_cache_entry *entry = _entry;
+   SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+   entry->state = _state;
+   SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+   vg_success( "   loaded (%s)\n", entry->reg_ptr->alias.foldername );
+}
+
+/*
+ * Handles the loading of an individual item
+ */
+static int addon_cache_load_request( enum addon_type type, u16 id,
+                                     addon_reg *reg, vg_str folder ){
+   
+   /* load content files
+    * --------------------------------- */
+   vg_str content_path = folder;
+
+   vg_msg root = {0};
+   root.buf = reg->metadata;
+   root.len = reg->metadata_len;
+   root.max = sizeof(reg->metadata);
 
-      vg_strcat( folder, reg->foldername );
+   const char *kv_content = vg_msg_seekkvstr( &root, "content", 0 );
+   if( kv_content ){
+      vg_strcat( &content_path, "/" );
+      vg_strcat( &content_path, kv_content );
+   }
+   else{
+      vg_error( "   No content paths in metadata\n" );
+      return 0;
+   }
+
+   if( !vg_strgood( &content_path ) ) {
+      vg_error( "   Metadata path too long\n" );
+      return 0;
+   }
+   
+   if( type == k_addon_type_board ){
+      struct player_board *board = addon_cache_item( type, id );
+      player_board_load( board, content_path.buffer );
+      return 1;
+   }
+   else if( type == k_addon_type_player ){
+      struct player_model *model = addon_cache_item( type, id );
+      player_model_load( model, content_path.buffer );
       return 1;
    }
+   else {
+      return 0;
+   }
+
+   return 0;
+}
+
+static void addon_cache_free_item( enum addon_type type, u16 id ){
+   if( type == k_addon_type_board ){
+      struct player_board *board = addon_cache_item( type, id );
+      player_board_unload( board );
+   }
+   else if( type == k_addon_type_player ){
+      struct player_model *model = addon_cache_item( type, id );
+      player_model_unload( model );
+   }
+}
+
+/*
+ * Goes over cache item load requests and calls the above ^
+ */
+static void addon_cache_load_loop(void){
+   vg_info( "Running load loop\n" );
+   char path_buf[4096];
+
+   for( u32 type=0; type<k_addon_type_max; type++ ){
+      struct addon_cache *cache = &addon_system.cache[type];
+
+      for( u32 id=1; id<=cache->pool.count; id++ ){
+         addon_cache_entry *entry = vg_pool_item( &cache->pool, id );
+
+         SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+         if( entry->state == k_addon_cache_state_load_request ){
+            vg_info( "process cache load request (%u#%u, reg:%u)\n",
+                        type, id, entry->reg_index );
+
+            if( entry->reg_index >= addon_count(type) ){
+               /* should maybe have a different value for this case */
+               entry->state = k_addon_cache_state_none;
+               SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+               continue;
+            }
+
+            SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+
+            /* continue with the request */
+            addon_reg *reg = get_addon_from_index( type, entry->reg_index );
+            entry->reg_ptr = reg;
+
+            vg_str folder;
+            vg_strnull( &folder, path_buf, 4096 );
+            if( addon_get_content_folder( reg, &folder ) ){
+               if( addon_cache_load_request( type, id, reg, folder ) ){
+                  vg_async_call( async_addon_setstate, 
+                                 entry, k_addon_cache_state_loaded );
+                  continue;
+               }
+            }
+            
+            vg_warn( "cache item did not load (%u#%u)\n", type, id );
+            SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+            entry->state = k_addon_cache_state_none;
+            SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+         }
+         else
+            SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+      }
+   }
+}
+
+/*
+ * Perform the cache interactions required to create a viewslot which will
+ * eventually be loaded by other parts of the system.
+ */
+static u16 addon_cache_create_viewer( enum addon_type type, u16 reg_id ){
+   struct addon_cache *cache = &addon_system.cache[type];
+   vg_pool *pool = &cache->pool;
+
+   u16 cache_id = addon_cache_fetch( type, reg_id );
+   if( !cache_id ){
+      cache_id = addon_cache_alloc( type, reg_id );
+
+      if( cache_id ){
+         SDL_AtomicLock( &addon_system.sl_cache_using_resources );
+         addon_cache_entry *entry = vg_pool_item( pool, cache_id );
+
+         if( entry->state == k_addon_cache_state_loaded ){
+            addon_cache_free_item( type, cache_id );
+         }
+
+         entry->state = k_addon_cache_state_load_request;
+         SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
+      }
+   }
+
+   if( cache_id )
+      vg_pool_watch( pool, cache_id );
+
+   return cache_id;
+}
+
+static void addon_cache_watch( enum addon_type type, u16 cache_id ){
+   if( !cache_id ) return;
+
+   struct addon_cache *cache = &addon_system.cache[type];
+   vg_pool *pool = &cache->pool;
+   vg_pool_watch( pool, cache_id );
+}
+
+static void addon_cache_unwatch( enum addon_type type, u16 cache_id ){
+   if( !cache_id ) return;
+
+   struct addon_cache *cache = &addon_system.cache[type];
+   vg_pool *pool = &cache->pool;
+   vg_pool_unwatch( pool, cache_id );
 }
 
 #endif /* ADDON_C */