+++ /dev/null
-#ifndef ADDON_C
-#define ADDON_C
-
-#include "addon.h"
-#include "addon_types.h"
-#include "vg/vg_msg.h"
-#include "steam.h"
-#include "workshop.h"
-
-static u32 addon_count( enum addon_type type, u32 ignoreflags ){
- if( ignoreflags ){
- u32 typecount = 0, count = 0;
- for( u32 i=0; typecount<addon_count( type, 0 ); i++ ){
- addon_reg *reg = &addon_system.registry[i];
- if( reg->alias.type == type ){
- typecount ++;
-
- if( reg->flags & ignoreflags )
- continue;
-
- count ++;
- }
- }
-
- return count;
- }
- else
- return addon_system.registry_type_counts[ type ];
-}
-
-
-/* these kind of suck, oh well. */
-static addon_reg *get_addon_from_index( enum addon_type type, u32 index,
- u32 ignoreflags ){
- u32 typecount = 0, count = 0;
- for( u32 i=0; typecount<addon_count(type,0); i++ ){
- addon_reg *reg = &addon_system.registry[i];
- if( reg->alias.type == type ){
- typecount ++;
-
- if( reg->flags & ignoreflags )
- continue;
-
- if( index == count )
- return reg;
-
- count ++;
- }
- }
-
- return NULL;
-}
-
-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->alias.type == type ){
- if( reg == a )
- return count;
-
- count ++;
- }
- }
-
- return 0xffffffff;
-}
-
-static u32 addon_match( addon_alias *alias ){
- if( alias->type == k_addon_type_none ) return 0xffffffff;
-
- u32 foldername_djb2 = 0;
- if( !alias->workshop_id )
- foldername_djb2 = vg_strdjb2( alias->foldername );
-
- u32 count = 0;
- for( u32 i=0; count<addon_system.registry_type_counts[alias->type]; i++ ){
- addon_reg *reg = &addon_system.registry[i];
- if( reg->alias.type == alias->type ){
-
- if( alias->workshop_id ){
- if( alias->workshop_id == reg->alias.workshop_id )
- return count;
- }
- else{
- if( reg->foldername_hash == foldername_djb2 ){
- if( !strcmp( reg->alias.foldername, alias->foldername ) ){
- return count;
- }
- }
- }
-
- count ++;
- }
- }
-
- return 0xffffffff;
-}
-
-/*
- * Create a string version of addon alias in buf
- */
-static void addon_alias_uid( addon_alias *alias, char buf[ADDON_UID_MAX] ){
- if( alias->workshop_id ){
- snprintf( buf, 128, "sr%03d-steam-"PRINTF_U64,
- alias->type, alias->workshop_id );
- }
- else {
- snprintf( buf, 128, "sr%03d-local-%s",
- alias->type, alias->foldername );
- }
-}
-
-/*
- * equality check
- */
-static int addon_alias_eq( addon_alias *a, addon_alias *b ){
- if( a->type == b->type ){
- if( a->workshop_id == b->workshop_id ){
- if( a->workshop_id )
- return 1;
- else
- return !strcmp( a->foldername, b->foldername );
- }
- else
- return 0;
- }
- else return 0;
-}
-
-/*
- * make alias represent NULL.
- */
-static void invalidate_addon_alias( addon_alias *alias ){
- alias->type = k_addon_type_none;
- alias->workshop_id = 0;
- alias->foldername[0] = '\0';
-}
-
-/*
- * parse uid to alias. returns 1 if successful
- */
-static int addon_uid_to_alias( const char *uid, addon_alias *alias ){
-/* 1
- * 01234567890123
- * sr&&&-@@@@@-#*
- * | | |
- * type | id
- * |
- * location
- */
- if( strlen(uid) < 13 ){
- invalidate_addon_alias( alias );
- return 0;
- }
- if( !((uid[0] == 's') && (uid[1] == 'r')) ){
- invalidate_addon_alias( alias );
- return 0;
- }
-
- char type[4];
- memcpy( type, uid+2, 3 );
- type[3] = '\0';
- alias->type = atoi(type);
-
- char location[6];
- memcpy( location, uid+6, 5 );
- location[5] = '\0';
-
- if( !strcmp(location,"steam") )
- alias->workshop_id = atoll( uid+12 );
- else if( !strcmp(location,"local") ){
- alias->workshop_id = 0;
- vg_strncpy( uid+12, alias->foldername, 64, k_strncpy_always_add_null );
- }
- else{
- invalidate_addon_alias( alias );
- return 0;
- }
-
- return 1;
-}
-
-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;
- }
- }
- }
-}
-
-/*
- * Scanning routines
- * -----------------------------------------------------------------------------
- */
-
-/*
- * Reciever for scan completion. copies the registry counts back into main fred
- */
-static void async_addon_reg_update( void *data, u32 size )
-{
- vg_info( "Registry update notify\n" );
-
- 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++ ){
- enum addon_type type = addon_system.registry[i].alias.type;
- addon_system.registry_type_counts[ type ] ++;
- }
-}
-
-static void addon_set_foldername( addon_reg *reg, const char name[64] ){
- vg_strncpy( name, reg->alias.foldername, 64, k_strncpy_always_add_null );
- reg->foldername_hash = vg_strdjb2( reg->alias.foldername );
-}
-
-/*
- * Create a new registry
- */
-static addon_reg *addon_alloc_reg( PublishedFileId_t workshop_id,
- enum addon_type type ){
- if( addon_system.registry_count == ADDON_MOUNTED_MAX ){
- vg_error( "You have too many addons installed!\n" );
- return NULL;
- }
-
- addon_reg *reg = &addon_system.registry[ addon_system.registry_count ];
- reg->flags = 0;
- reg->metadata_len = 0;
- reg->cache_id = 0;
- reg->state = k_addon_state_indexed;
- reg->alias.workshop_id = workshop_id;
- reg->alias.foldername[0] = '\0';
- reg->alias.type = type;
-
- if( workshop_id ){
- char foldername[64];
- snprintf( foldername, 64, PRINTF_U64, workshop_id );
- addon_set_foldername( reg, foldername );
- }
- return reg;
-}
-
-/*
- * If the addon.inf exists int the folder, load into the reg
- */
-static int addon_try_load_metadata( addon_reg *reg, vg_str folder_path ){
- vg_str meta_path = folder_path;
- vg_strcat( &meta_path, "/addon.inf" );
- if( !vg_strgood( &meta_path ) ){
- vg_error( "The metadata path is too long\n" );
- return 0;
- }
-
- FILE *fp = fopen( meta_path.buffer, "rb" );
- if( !fp ){
- vg_error( "Could not open the '%s'\n", meta_path.buffer );
- return 0;
- }
-
- reg->metadata_len = fread( reg->metadata, 1, 512, fp );
- if( reg->metadata_len != 512 ){
- if( !feof(fp) ){
- fclose(fp);
- vg_error( "unknown error codition" );
- reg->metadata_len = 0;
- return 0;
- }
- }
- fclose(fp);
- return 1;
-}
-
-static void addon_print_info( addon_reg *reg ){
- vg_info( "addon_reg #%u{\n", addon_system.registry_count );
- 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( " cache_id: %hu\n", reg->cache_id );
- vg_info( "}\n" );
-}
-
-static void addon_mount_finish( addon_reg *reg ){
-#if 0
- addon_print_info( reg );
-#endif
- addon_system.registry_count ++;
-}
-
-/*
- * Mount a fully packaged addon, one that certainly has a addon.inf
- */
-static addon_reg *addon_mount_workshop_folder( PublishedFileId_t workshop_id,
- vg_str folder_path )
-{
- 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 addon_type type = k_addon_type_none;
- vg_msg msg;
- vg_msg_init( &msg, reg->metadata, reg->metadata_len );
-
- if( vg_msg_seekframe( &msg, "workshop" )){
- type = vg_msg_getkvu32( &msg, "type", 0 );
- }
-
- if( type == k_addon_type_none ){
- vg_error( "Cannot determine addon type\n" );
- return NULL;
- }
-
- reg->alias.type = type;
- addon_mount_finish( reg );
- return reg;
-}
-
-/*
- * Mount a local folder. may or may not have addon.inf
- */
-static addon_reg *addon_mount_local_addon( const char *folder,
- enum addon_type type,
- const char *content_ext )
-{
- char folder_path_buf[4096];
- vg_str folder_path;
- vg_strnull( &folder_path, folder_path_buf, 4096 );
- vg_strcat( &folder_path, folder );
-
- const char *folder_name = vg_strch( &folder_path, '/' )+1;
- u32 folder_hash = vg_strdjb2(folder_name);
- for( u32 i=0; i<addon_system.registry_count; i++ ){
- addon_reg *reg = &addon_system.registry[i];
-
- 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;
- }
- }
- }
-
- addon_reg *reg = addon_alloc_reg( 0, type );
- if( !reg ) return NULL;
- addon_set_foldername( reg, folder_name );
- addon_try_load_metadata( reg, folder_path );
-
- if( reg->metadata_len == 0 ){
- /* create our own content commands */
- vg_msg msg;
- vg_msg_init( &msg, reg->metadata, sizeof(reg->metadata) );
-
- u32 content_count = 0;
-
- vg_strcat( &folder_path, "" );
- vg_warn( "Creating own metadata for: %s\n", folder_path.buffer );
-
- vg_dir subdir;
- if( !vg_dir_open(&subdir, folder_path.buffer) ){
- vg_error( "Failed to open '%s'\n", folder_path.buffer );
- return NULL;
- }
-
- while( vg_dir_next_entry(&subdir) ){
- if( vg_dir_entry_type(&subdir) == k_vg_entry_type_file ){
- const char *fname = vg_dir_entry_name(&subdir);
- vg_str file = folder_path;
- vg_strcat( &file, "/" );
- vg_strcat( &file, fname );
- if( !vg_strgood( &file ) ) continue;
-
- char *ext = vg_strch( &file, '.' );
- if( !ext ) continue;
- if( strcmp(ext,content_ext) ) continue;
-
- vg_msg_wkvstr( &msg, "content", fname );
- content_count ++;
- }
- }
- vg_dir_close(&subdir);
-
- if( !content_count ) return NULL;
- if( msg.error == k_vg_msg_error_OK )
- reg->metadata_len = msg.cur.co;
- else{
- vg_error( "Error creating metadata: %d\n", msg.error );
- return NULL;
- }
- }
-
- addon_mount_finish( reg );
- return reg;
-}
-
-/*
- * Check all subscribed items
- */
-static void addon_mount_workshop_items(void){
- if( skaterift.demo_mode ){
- vg_info( "Won't load workshop items in demo mode\n" );
- return;
- }
- if( !steam_ready ) return;
-
- /*
- * Steam workshop scan
- */
- vg_info( "Mounting steam workshop subscriptions\n" );
- PublishedFileId_t workshop_ids[ ADDON_MOUNTED_MAX ];
- u32 workshop_count = ADDON_MOUNTED_MAX;
-
- vg_async_item *call = vg_async_alloc(
- sizeof(struct async_workshop_installed_files_info));
- struct async_workshop_installed_files_info *info = call->payload;
- info->buffer = workshop_ids;
- info->len = &workshop_count;
- vg_async_dispatch( call, async_workshop_get_installed_files );
- vg_async_stall();
-
- for( u32 j=0; j<workshop_count; j++ ){
- /* check for existance in both our caches
- * ----------------------------------------------------------*/
- PublishedFileId_t id = workshop_ids[j];
- for( u32 i=0; i<addon_system.registry_count; i++ ){
- addon_reg *reg = &addon_system.registry[i];
-
- if( reg->alias.workshop_id == id ){
- reg->state = k_addon_state_indexed;
- goto next_file_workshop;
- }
- }
-
- vg_async_item *call1 =
- vg_async_alloc( sizeof(struct async_workshop_filepath_info) );
-
- char path[ 4096 ];
-
- struct async_workshop_filepath_info *info = call1->payload;
- info->buf = path;
- info->id = id;
- info->len = vg_list_size(path);
- vg_async_dispatch( call1, async_workshop_get_filepath );
- vg_async_stall(); /* too bad! */
-
- vg_str folder = {.buffer = path, .i=strlen(path), .len=4096};
- addon_mount_workshop_folder( id, folder );
-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.
- */
-static void addon_mount_content_folder( enum addon_type type,
- const char *base_folder,
- const char *content_ext )
-{
- vg_info( "Mounting addons(type:%d) matching skaterift/%s/*/*%s\n",
- type, base_folder, content_ext );
-
- char path_buf[4096];
- vg_str path;
- vg_strnull( &path, path_buf, 4096 );
- vg_strcat( &path, base_folder );
-
- vg_dir dir;
- if( !vg_dir_open(&dir,path.buffer) ){
- vg_error( "vg_dir_open('%s') failed\n", path.buffer );
- return;
- }
-
- vg_strcat(&path,"/");
-
- while( vg_dir_next_entry(&dir) ){
- if( vg_dir_entry_type(&dir) == k_vg_entry_type_dir ){
- const char *d_name = vg_dir_entry_name(&dir);
-
- vg_str folder = path;
- if( strlen( d_name ) > ADDON_FOLDERNAME_MAX ){
- vg_warn( "folder too long: %s\n", d_name );
- continue;
- }
-
- vg_strcat( &folder, d_name );
- if( !vg_strgood( &folder ) ) continue;
-
- addon_mount_local_addon( folder.buffer, type, content_ext );
- }
- }
- 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, int async){
- if( reg->alias.workshop_id ){
- struct async_workshop_filepath_info *info = NULL;
- vg_async_item *call = NULL;
-
- if( async ){
- call = vg_async_alloc( sizeof(struct async_workshop_filepath_info) );
- info = call->payload;
- }
- else
- info = alloca( sizeof(struct async_workshop_filepath_info) );
-
- info->buf = folder->buffer;
- info->id = reg->alias.workshop_id;
- info->len = folder->len;
-
- if( async ){
- vg_async_dispatch( call, async_workshop_get_filepath );
- vg_async_stall(); /* too bad! */
- }
- else {
- async_workshop_get_filepath( info, 0 );
- }
-
- if( info->buf[0] == '\0' ){
- vg_error( "Failed SteamAPI_GetItemInstallInfo(" PRINTF_U64 ")\n",
- reg->alias.workshop_id );
- return 0;
- }
- folder->i = strlen( folder->buffer );
- return 1;
- }
- else{
- folder->i = 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, 0 ) ){
- reg = get_addon_from_index( type, reg_index, 0 );
- 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, 0 ) )
- reg = get_addon_from_index( type, reg_index, 0 );
-
- 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 msg;
- vg_msg_init( &msg, reg->metadata, reg->metadata_len );
-
- const char *kv_content = vg_msg_getkvstr( &msg, "content" );
- 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,0) ){
- /* 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, 0 );
- entry->reg_ptr = reg;
-
- vg_str folder;
- vg_strnull( &folder, path_buf, 4096 );
- if( addon_get_content_folder( reg, &folder, 1 ) ){
- 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 u16 addon_cache_create_viewer_from_uid( enum addon_type type,
- char uid[ADDON_UID_MAX] ){
- addon_alias q;
- if( !addon_uid_to_alias( uid, &q ) ) return 0;
- if( q.type != type ) return 0;
-
- u32 reg_id = addon_match( &q );
-
- if( reg_id == 0xffffffff ){
- vg_warn( "We dont have the addon '%s' installed.\n", uid );
- return 0;
- }
- else {
- return addon_cache_create_viewer( type, reg_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 */
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff