From: hgn <hgodden00@gmail.com>
Date: Tue, 20 Jun 2023 12:11:35 +0000 (+0100)
Subject: quite a lot of changes
X-Git-Url: https://harrygodden.com/git/?a=commitdiff_plain;h=02e009ae6e20938675277e9ce2f467e17b170cc7;hp=cbeec2e44e93ab43ccde54c2dd9cd02f559ebef8;p=carveJwlIkooP6JGAAIwe30JlM.git

quite a lot of changes
---

diff --git a/addon.c b/addon.c
index 0346d01..8067eca 100644
--- a/addon.c
+++ b/addon.c
@@ -2,21 +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"
 
-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;
 
@@ -27,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;
 
@@ -42,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;
                }
             }
@@ -74,44 +73,29 @@ 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 );
 
-   struct cache_inf {
-      size_t stride;
-      u32 count;
-   }
-   static cache_inf[] = {
-      [k_workshop_file_type_board] = { 
-         .stride = sizeof(struct player_board),
-         .count  = CACHE_BOARD_MAX 
-      },
-      [k_workshop_file_type_player] = {
-         .stride = sizeof(struct player_model),
-         .count  = CACHE_PLAYER_MAX
-      }
-   };
-
-   for( u32 i=0; i<vg_list_size(cache_inf); i++ ){
-      struct cache_inf *inf = &cache_inf[i];
-      struct addon_cache *cache = &addon_system.cache[i];
+   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->count ){
+      if( inf->cache_count ){
          /* create the allocations pool */
-         u32 alloc_size = sizeof(struct addon_cache_entry)*inf->count;
+         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->count;
+         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->stride*inf->count;
+         u32 cache_size = inf->cache_stride*inf->cache_count;
          cache->items = vg_linear_alloc( vg_mem.rtmemory, cache_size );
-         cache->stride = inf->stride;
+         cache->stride = inf->cache_stride;
          memset( cache->items, 0, cache_size );
 
-         for( i32 j=0; j<inf->count; j++ ){
+         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;
@@ -132,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;
@@ -160,9 +145,9 @@ VG_STATIC addon_reg *addon_alloc_reg( PublishedFileId_t workshop_id,
    reg->metadata_len = 0;
    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];
@@ -204,9 +189,9 @@ 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( "  cache_id: %hu\n", reg->cache_id );
    vg_info( "}\n" );
@@ -223,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;
@@ -241,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;
 }
@@ -255,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];
@@ -268,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;
          }
@@ -357,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;
          }
@@ -385,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 )
 {
@@ -425,19 +410,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 );
@@ -445,20 +433,22 @@ 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;
 
-      vg_strcat( folder, reg->foldername );
+      if( !local_folder ) return 0;
+      vg_strcat( folder, local_folder );
+      vg_strcat( folder, reg->alias.foldername );
       return 1;
    }
 }
 
-static u16 addon_cache_fetch( enum workshop_file_type type, u32 reg_index ){
-   vg_assert_thread( k_thread_purpose_main );
-
+/*
+ * 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 ) ){
@@ -470,7 +460,10 @@ static u16 addon_cache_fetch( enum workshop_file_type type, u32 reg_index ){
    return 0;
 }
 
-static u16 addon_cache_alloc( enum workshop_file_type type, u32 reg_index ){
+/*
+ * 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 );
@@ -497,14 +490,20 @@ static u16 addon_cache_alloc( enum workshop_file_type type, u32 reg_index ){
    }
 }
 
-static void *addon_cache_item( enum workshop_file_type type, u16 id ){
+/*
+ * 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);
 }
 
-static void *addon_cache_item_if_loaded( enum workshop_file_type type, u16 id ){
+/*
+ * 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];
@@ -515,4 +514,172 @@ static void *addon_cache_item_if_loaded( enum workshop_file_type type, u16 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);
+
+   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 */
diff --git a/addon.h b/addon.h
index 949a5d0..768bede 100644
--- a/addon.h
+++ b/addon.h
@@ -3,7 +3,7 @@
 
 #include "skaterift.h"
 #include "vg/vg_steam_ugc.h"
-#include "workshop_types.h"
+#include "addon_types.h"
 #include "vg/vg_mem_pool.h"
 
 #include "world.h"
@@ -14,22 +14,23 @@
 /* total count that we have knowledge of */
 #define ADDON_MOUNTED_MAX 128
 
-/* in memory and loaded stuffs */
-#define CACHE_BOARD_MAX  10
-#define CACHE_PLAYER_MAX 10
-
 typedef struct addon_reg addon_reg;
 typedef struct addon_cache_entry addon_cache_entry;
+typedef struct addon_alias addon_alias;
+
+struct addon_alias {
+   enum addon_type type;
+   PublishedFileId_t workshop_id;
+   char foldername[ ADDON_FOLDERNAME_MAX ];
+};
+
 struct {
    struct addon_reg{
-      PublishedFileId_t workshop_id;
-
-      enum workshop_file_type type;
+      addon_alias alias;
+      u32 foldername_hash;
       u8 metadata[512];  /* vg_msg buffer */
       u32 metadata_len;
 
-      char foldername[ ADDON_FOLDERNAME_MAX ];
-      u32 foldername_hash;
       u16 cache_id;
 
       enum addon_state{
@@ -43,7 +44,7 @@ struct {
    u32 registry_count;
 
    /* deffered: updates in main thread */
-   u32 registry_type_counts[k_workshop_file_type_max];
+   u32 registry_type_counts[k_addon_type_max];
 
    struct addon_cache{
       struct addon_cache_entry{
@@ -65,58 +66,35 @@ struct {
       void *items;  /* the real data */
       size_t stride;
    }
-   cache[k_workshop_file_type_max];
+   cache[k_addon_type_max];
    SDL_SpinLock sl_cache_using_resources;
-
-
-
-#if 0
-
-
-
-   /* caches */
-   struct cache_board{
-      struct player_board board;
-      
-      u32 reg_index;
-      addon_reg *reg_ptr;
-      vg_pool_node cachenode;
-   }
-   *boards;
-   vg_pool board_cache;
-
-   struct cache_playermodel{
-      struct player_model model;
-
-      u32 reg_index;
-      addon_reg *reg_ptr;
-      vg_pool_node cachenode;
-   }
-   *playermodels;
-   vg_pool playermodel_cache;
-#endif
-
 }
 static addon_system;
 
 static void addon_system_init( void );
-static u32 addon_count( enum workshop_file_type type );
-static addon_reg *get_addon_from_index(enum workshop_file_type type, u32 index);
-static u32 get_index_from_addon( enum workshop_file_type type, addon_reg *a );
+static u32 addon_count( enum addon_type type );
+static addon_reg *get_addon_from_index(enum addon_type type, u32 index);
+static u32 get_index_from_addon( enum addon_type type, addon_reg *a );
 static int addon_get_content_folder( addon_reg *reg, vg_str *folder );
 
 /* scanning routines */
-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 );
 VG_STATIC void addon_mount_workshop_items(void);
 VG_STATIC void async_addon_reg_update( void *data, u32 size );
 VG_STATIC addon_reg *addon_mount_local_addon( const char *folder,
-                                              enum workshop_file_type type,
+                                              enum addon_type type,
                                               const char *content_ext );
-static u16 addon_cache_fetch( enum workshop_file_type type, u32 reg_index );
-static u16 addon_cache_alloc( enum workshop_file_type type, u32 reg_index );
-static void *addon_cache_item( enum workshop_file_type type, u16 id );
-static void *addon_cache_item_if_loaded( enum workshop_file_type type, u16 id );
+static u16 addon_cache_fetch( enum addon_type type, u32 reg_index );
+static u16 addon_cache_alloc( enum addon_type type, u32 reg_index );
+static void *addon_cache_item( enum addon_type type, u16 id );
+static void *addon_cache_item_if_loaded( enum addon_type type, u16 id );
+static void async_addon_setstate( void *data, u32 size );
+static void addon_cache_load_loop(void);
+static u16 addon_cache_create_viewer( enum addon_type type, u16 reg_id);
+
+static void addon_cache_watch( enum addon_type type, u16 cache_id );
+static void addon_cache_unwatch( enum addon_type type, u16 cache_id );
 
 #endif /* ADDON_H */
diff --git a/addon_types.h b/addon_types.h
new file mode 100644
index 0000000..fa8ab96
--- /dev/null
+++ b/addon_types.h
@@ -0,0 +1,42 @@
+#ifndef ADDON_TYPES_H
+#define ADDON_TYPES_H
+
+enum addon_type{
+   k_addon_type_none   = 0,
+   k_addon_type_board  = 1,
+   k_addon_type_world  = 2,
+   k_addon_type_player = 3,
+   k_addon_type_max
+};
+
+#ifdef VG_GAME
+
+#include "vg/vg_stdint.h"
+#include "stddef.h"
+#include "world.h"
+#include "player.h"
+
+struct addon_type_info {
+   size_t cache_stride;
+   u16 cache_count;
+   const char *local_content_folder;
+}
+static addon_type_infos[] = {
+   [k_addon_type_board] = { 
+      .local_content_folder = "boards/",
+      .cache_stride = sizeof(struct player_board),
+      .cache_count  = 10
+   },
+   [k_addon_type_player] = {
+      .local_content_folder = "playermodels/",
+      .cache_stride = sizeof(struct player_model),
+      .cache_count  = 10
+   },
+   [k_addon_type_world] = {
+      .local_content_folder = "maps/"
+   }
+};
+
+#endif
+
+#endif /* ADDON_TYPES_H */
diff --git a/blender_export.py b/blender_export.py
index 32e548b..7117b4c 100644
--- a/blender_export.py
+++ b/blender_export.py
@@ -3403,7 +3403,8 @@ def cv_draw_lines():
          cv_view_shader, 'LINES', \
          { "pos":cv_view_verts, "color":cv_view_colours })
 
-   lines.draw( cv_view_shader )
+   if bpy.context.scene.SR_data.gizmos:
+      lines.draw( cv_view_shader )
 
    cv_view_verts = []
    cv_view_colours = []
@@ -3480,8 +3481,8 @@ def draw_cone_twist( center, vx, vy, va ):
       p0 = center + (axis + vx*c0 + vy*s0).normalized() * size
       p1 = center + (axis + vx*c1 + vy*s1).normalized() * size
 
-      col0 = ( abs(c0), abs(s0), 0.0, 1.0 )
-      col1 = ( abs(c1), abs(s1), 0.0, 1.0 )
+      col0 = ( abs(c0), abs(s0), 0.0 )
+      col1 = ( abs(c1), abs(s1), 0.0 )
 
       cv_view_verts += [center, p0, p0, p1]
       cv_view_colours += [ (0,0,0), col0, col0, col1 ]
diff --git a/build.c b/build.c
index b3a4352..03742ef 100644
--- a/build.c
+++ b/build.c
@@ -5,7 +5,7 @@
 #include "vg/vg_build.h"
 #include "vg/vg_build_utils_shader.h"
 #include "vg/vg_msg.h"
-#include "workshop_types.h"
+#include "addon_types.h"
 
 /* 
  * c build.c --release --clang 
@@ -83,32 +83,32 @@ void build_game( enum compiler compiler )
    vg_build_syscall( "mkdir -p %s/cfg", vg_compiler.build_dir );
 
 
-   write_generic_addon_inf( k_workshop_file_type_board, 
+   write_generic_addon_inf( k_addon_type_board, 
                             "Longboard", "board.mdl", 
                             "boards_src/skaterift_long/addon.inf");
-   write_generic_addon_inf( k_workshop_file_type_board, 
+   write_generic_addon_inf( k_addon_type_board, 
                             "Fractal", "board.mdl", 
                             "boards_src/skaterift_fract/addon.inf");
-   write_generic_addon_inf( k_workshop_file_type_board,
+   write_generic_addon_inf( k_addon_type_board,
                             "Striped", "board.mdl",
                             "boards_src/skaterift_striped/addon.inf");
-   write_generic_addon_inf( k_workshop_file_type_board,
+   write_generic_addon_inf( k_addon_type_board,
                             "Licco", "board.mdl",
                             "boards_src/skaterift_licco/addon.inf");
-   write_generic_addon_inf( k_workshop_file_type_board,
+   write_generic_addon_inf( k_addon_type_board,
                             "Hypno", "board.mdl",
                             "boards_src/skaterift_spiral/addon.inf");
-   write_generic_addon_inf( k_workshop_file_type_board,
+   write_generic_addon_inf( k_addon_type_board,
                             "Shark", "board.mdl",
                             "boards_src/skaterift_shark/addon.inf");
 
-   write_generic_addon_inf( k_workshop_file_type_player,
+   write_generic_addon_inf( k_addon_type_player,
                             "De'folde", "ch_new.mdl",
                             "playermodels_src/skaterift_new/addon.inf" );
-   write_generic_addon_inf( k_workshop_file_type_player,
+   write_generic_addon_inf( k_addon_type_player,
                             "Jordan", "ch_jordan.mdl",
                             "playermodels_src/skaterift_jordan/addon.inf" );
-   write_generic_addon_inf( k_workshop_file_type_player,
+   write_generic_addon_inf( k_addon_type_player,
                             "Outlaw", "ch_outlaw.mdl",
                             "playermodels_src/skaterift_outlaw/addon.inf" );
 
diff --git a/conf.h b/conf.h
deleted file mode 100644
index f83d5bd..0000000
--- a/conf.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef CONF_H
-#define CONF_H
-
-#define VG_GAME
-#include "vg/vg.h"
-
-VG_STATIC i32 k_playermdl_id = 0;
-VG_STATIC void conf_init(void){
-   VG_VAR_I32( k_playermdl_id, flags=VG_VAR_PERSISTENT ); /* TODO: .sav */
-}
-
-#endif /* CONF_H */
diff --git a/ent_skateshop.c b/ent_skateshop.c
index 279512b..16225c7 100644
--- a/ent_skateshop.c
+++ b/ent_skateshop.c
@@ -27,94 +27,20 @@ static inline int const_str_eq( u32 hash, const char *str, const char *cmp )
    return 0;
 }
 
-#if 0
-/*
- * Get an existing cache instance, allocate a new one to be loaded, or NULL if
- * there is no space
- */
-VG_STATIC struct cache_board *skateshop_cache_fetch_board( u32 registry_index )
-{
-   addon_reg *reg = NULL;
-
-   if( registry_index < addon_count( k_workshop_file_type_board ) ){
-      reg = get_addon_from_index( k_workshop_file_type_board, registry_index );
-
-      if( reg->userdata ){
-         return reg->userdata;
-      }
-   }
-
-   SDL_AtomicLock( &addon_system.sl_cache );
-   struct cache_board *min_board = vg_pool_lru( &addon_system.board_cache );
-
-   if( min_board ){
-      if( min_board->state == k_cache_board_state_loaded ){
-         player_board_unload( &min_board->board );
-         min_board->reg_ptr->userdata = NULL;
-      }
-
-      if( reg ){
-         vg_info( "Allocating board (reg:%u) '%s'\n", 
-                  registry_index, reg->foldername );
-      }
-      else{
-         vg_info( "Pre-allocating board (reg:%u) 'null'\n", registry_index );
-      }
-
-      min_board->reg_ptr = reg;
-      min_board->reg_index = registry_index;
-      min_board->state = k_cache_board_state_load_request;
-   }
-   else{
-      vg_error( "No free boards to load registry!\n" );
-   }
-
-   SDL_AtomicUnlock( &addon_system.sl_cache );
-   return min_board;
-}
-#endif
-
 VG_STATIC void skateshop_update_viewpage(void){
    u32 page = global_skateshop.selected_board_id/SKATESHOP_VIEW_SLOT_MAX;
-      
-   struct addon_cache *cache = &addon_system.cache[k_workshop_file_type_board];
-   vg_pool *pool = &cache->pool;
 
    for( u32 i=0; i<SKATESHOP_VIEW_SLOT_MAX; i++ ){
       u32 j = SKATESHOP_VIEW_SLOT_MAX-1-i;
       struct shop_view_slot *slot = &global_skateshop.shop_view_slots[j];
-
-      if( slot->cache_id )
-         vg_pool_unwatch( pool, slot->cache_id );
+      addon_cache_unwatch( k_addon_type_board, slot->cache_id );
    }
    
    for( u32 i=0; i<SKATESHOP_VIEW_SLOT_MAX; i++ ){
       struct shop_view_slot *slot = &global_skateshop.shop_view_slots[i];
       u32 request_id = page*SKATESHOP_VIEW_SLOT_MAX + i;
-
-      u16 id = addon_cache_fetch( k_workshop_file_type_board, request_id );
-      if( !id ){
-         id = addon_cache_alloc( k_workshop_file_type_board, request_id );
-
-         if( id ){
-            SDL_AtomicLock( &addon_system.sl_cache_using_resources );
-
-            addon_cache_entry *entry = vg_pool_item( &cache->pool, id );
-            struct player_board *board = 
-               addon_cache_item( k_workshop_file_type_board, id );
-
-            if( entry->state == k_addon_cache_state_loaded )
-               dynamic_model_unload( &board->mdl );
-
-            entry->state = k_addon_cache_state_load_request;
-            SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
-         }
-      }
-
-      if( id )
-         vg_pool_watch( pool, id );
-
-      slot->cache_id = id;
+      slot->cache_id = addon_cache_create_viewer( k_addon_type_board,
+                                                  request_id );
    }
 }
 
@@ -123,99 +49,8 @@ VG_STATIC void skateshop_update_viewpage(void){
  * -----------------------------------------------------------------------------
  */
 
-/*
- * Thread(or subroutine of thread), for checking view slots that weve installed.
- * Load the model if a view slot wants it
- */
-VG_STATIC void workshop_visibile_load_loop(void)
-{
-   vg_info( "Running load loop\n" );
-   char path_buf[4096];
-
-   /* boards */
-   struct addon_cache *cache = &addon_system.cache[k_workshop_file_type_board];
-
-   for( u32 id=1; id<=cache->pool.count; id++ ){
-      addon_cache_entry *entry = vg_pool_item( &cache->pool, id );
-      struct player_board *board = 
-         addon_cache_item( k_workshop_file_type_board, id );
-
-      SDL_AtomicLock( &addon_system.sl_cache_using_resources );
-      if( entry->state == k_addon_cache_state_load_request ){
-         vg_info( "process cache load request (type:%u#%u, reg:%u)\n",
-                     k_workshop_file_type_board, id, entry->reg_index );
-
-         if( entry->reg_index >= addon_count(k_workshop_file_type_board) ){
-            /* 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( k_workshop_file_type_board,
-                                                entry->reg_index );
-         entry->reg_ptr = reg;
-
-         vg_str folder;
-         vg_strnull( &folder, path_buf, 4096 );
-         if( !addon_get_content_folder( reg, &folder ) )
-            goto file_is_broken;
-
-
-         /* 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);
-
-         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" );
-            goto file_is_broken;
-         }
-
-         if( !vg_strgood( &content_path ) ) {
-            vg_error( "   Metadata path too long\n" );
-            goto file_is_broken;
-         }
-         
-         vg_info( "   Load content: %s\n", content_path.buffer );
-         
-         player_board_load( board, content_path.buffer );
-
-         /* WELL DONE */
-         vg_async_stall();
-
-         SDL_AtomicLock( &addon_system.sl_cache_using_resources );
-         entry->state = k_addon_cache_state_loaded;
-         SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
-
-         vg_success( "   loaded (%s)\n", entry->reg_ptr->foldername );
-         continue;
-
-file_is_broken:;
-         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 );
-   }
-}
-
-
 VG_STATIC void world_scan_thread( void *_args ){
-   addon_mount_content_folder( k_workshop_file_type_world, "maps", ".mdl" );
+   addon_mount_content_folder( k_addon_type_world, "maps", ".mdl" );
    addon_mount_workshop_items();
    vg_async_call( async_addon_reg_update, NULL, 0 );
    skaterift_end_op();
@@ -230,12 +65,12 @@ VG_STATIC void skateshop_op_world_scan(void){
 }
 
 VG_STATIC void board_processview_thread( void *_args ){
-   workshop_visibile_load_loop();
+   addon_cache_load_loop();
    skaterift_end_op();
 }
 
 VG_STATIC void board_scan_thread( void *_args ){
-   addon_mount_content_folder( k_workshop_file_type_board, "boards", ".mdl" );
+   addon_mount_content_folder( k_addon_type_board, "boards", ".mdl" );
    addon_mount_workshop_items();
    vg_async_call( async_addon_reg_update, NULL, 0 );
    vg_async_stall();
@@ -264,8 +99,8 @@ VG_STATIC void skateshop_init(void){
 }
 
 static u16 skateshop_selected_cache_id(void){
-   if( addon_count(k_workshop_file_type_board) ){
-      addon_reg *reg = get_addon_from_index(k_workshop_file_type_board,
+   if( addon_count(k_addon_type_board) ){
+      addon_reg *reg = get_addon_from_index(k_addon_type_board,
                                             global_skateshop.selected_board_id);
       return reg->cache_id;
    }
@@ -283,7 +118,7 @@ VG_STATIC void pointcloud_clear_async(void *_, u32 __)
    pointcloud_animate( k_pointcloud_anim_opening );
 }
 
-VG_STATIC void skateshop_preview_loader_thread( void *_data )
+VG_STATIC void skateshop_world_preview_loader_thread( void *_data )
 {
    addon_reg *reg = _data;
 
@@ -321,15 +156,15 @@ VG_STATIC void skateshop_preview_loader_thread( void *_data )
    }
 }
 
-VG_STATIC void skateshop_preview_loader_thread_and_end( void *_data ){
-   skateshop_preview_loader_thread( _data );
+VG_STATIC void skateshop_world_preview_loader_thread_and_end( void *_data ){
+   skateshop_world_preview_loader_thread( _data );
    skaterift_end_op();
 }
 
 VG_STATIC void skateshop_load_world_preview( addon_reg *reg )
 {
    skaterift_begin_op( k_async_op_world_load_preview );
-   vg_loader_start( skateshop_preview_loader_thread_and_end, reg );
+   vg_loader_start( skateshop_world_preview_loader_thread_and_end, reg );
 }
 
 /*
@@ -405,7 +240,7 @@ VG_STATIC void global_skateshop_preupdate(void)
 
       if( button_down( k_srbind_mright ) ){
          if( global_skateshop.selected_board_id+1 < 
-               addon_count(k_workshop_file_type_board) )
+               addon_count(k_addon_type_board) )
          {
             global_skateshop.selected_board_id ++;
          }
@@ -421,45 +256,51 @@ VG_STATIC void global_skateshop_preupdate(void)
          vg_info( "chose board from skateshop (%u)\n", 
                      global_skateshop.selected_board_id );
 
-         struct addon_cache *cache = 
-            &addon_system.cache[k_workshop_file_type_board];
-         addon_cache_entry *entry = vg_pool_item( &cache->pool, cache_id );
-
-         if( localplayer.board_view_slot ){
-            vg_pool_unwatch( &cache->pool, localplayer.board_view_slot );
-         }
-
+         addon_cache_unwatch( k_addon_type_board, localplayer.board_view_slot );
+         addon_cache_watch( k_addon_type_board, cache_id );
          localplayer.board_view_slot = cache_id;
-         vg_pool_watch( &cache->pool, cache_id );
+
          global_skateshop_exit();
          skaterift_write_savedata();
          return;
       }
    }
    else if( shop->type == k_skateshop_type_charshop ){
+      if( skaterift.async_op != k_async_op_none ) return;
+
       gui_helper_action( axis_display_string( k_sraxis_mbrowse_h ), "browse" );
       gui_helper_action( button_display_string( k_srbind_mback ), "exit" );
       gui_helper_action( button_display_string( k_srbind_maccept ), "pick" );
 
+      int changed = 0;
+
       if( button_down( k_srbind_mleft ) ){
-         if( k_playermdl_id > 0 ){
-            k_playermdl_id --;
+         if( global_skateshop.selected_player_id > 0 ){
+            global_skateshop.selected_player_id --;
          }
          else{
-            k_playermdl_id = 2; /* HACK */
+            global_skateshop.selected_player_id = 
+               addon_count(k_addon_type_player) -1;
          }
-         temp_update_playermodel(); /* HACK */
+
+         changed = 1;
       }
 
       if( button_down( k_srbind_mright ) ){
-         if( k_playermdl_id+1 < 3 ){
-            k_playermdl_id ++;
+         if( global_skateshop.selected_player_id+1 < 
+               addon_count(k_addon_type_player) ){
+            global_skateshop.selected_player_id ++;
          }
          else{
-            k_playermdl_id = 0;  /* HACK */
+            global_skateshop.selected_player_id = 0;
          }
-         temp_update_playermodel(); /* HACK */
-         /*lol*/
+
+         changed = 1;
+      }
+
+      if( changed ){
+         player__use_model( &localplayer, global_skateshop.selected_player_id );
+         skateshop_op_processview();
       }
 
       if( button_down( k_srbind_maccept ) ){
@@ -470,7 +311,7 @@ VG_STATIC void global_skateshop_preupdate(void)
       int browseable = 0,
           loadable = 0;
 
-      if( addon_count(k_workshop_file_type_world) &&
+      if( addon_count(k_addon_type_world) &&
             ((skaterift.async_op == k_async_op_none)||
              (skaterift.async_op == k_async_op_world_load_preview))){
          gui_helper_action( axis_display_string(k_sraxis_mbrowse_h), "browse" );
@@ -497,7 +338,7 @@ VG_STATIC void global_skateshop_preupdate(void)
 
          if( button_down( k_srbind_mright ) ){
             if( global_skateshop.selected_world_id+1 < 
-                     addon_count(k_workshop_file_type_world) )
+                     addon_count(k_addon_type_world) )
             {
                global_skateshop.selected_world_id ++;
                change = 1;
@@ -510,7 +351,7 @@ VG_STATIC void global_skateshop_preupdate(void)
       }
 
       if( skaterift.async_op == k_async_op_none ){
-         addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
+         addon_reg *reg = get_addon_from_index( k_addon_type_world,
             global_skateshop.selected_world_id );
 
          /* automatically load in clouds */
@@ -568,7 +409,7 @@ VG_STATIC void skateshop_render_boardshop(void)
                                   mdl_entity_id_id(shop->boards.id_display));
 
    SDL_AtomicLock( &addon_system.sl_cache_using_resources );
-   struct addon_cache *cache = &addon_system.cache[k_workshop_file_type_board];
+   struct addon_cache *cache = &addon_system.cache[k_addon_type_board];
    
    /* Render loaded boards in the view slots */
    for( u32 i=0; i<slot_count; i++ ){
@@ -584,7 +425,7 @@ VG_STATIC void skateshop_render_boardshop(void)
          goto fade_out;
 
       struct player_board *board = 
-         addon_cache_item( k_workshop_file_type_board, slot->cache_id );
+         addon_cache_item( k_addon_type_board, slot->cache_id );
 
       mdl_transform xform;
       transform_identity( &xform );
@@ -641,12 +482,12 @@ fade_out:;
    mlocal[3][2] = -0.7f;
    m4x3_mul( mrack, mlocal, mmdl );
 
-   if( addon_count(k_workshop_file_type_board) ){
+   if( addon_count(k_addon_type_board) ){
       char buf[16];
       int i=0;
       i+=highscore_intl( buf+i, global_skateshop.selected_board_id+1, 3 );
       buf[i++] = '/';
-      i+=highscore_intl( buf+i, addon_count(k_workshop_file_type_board), 3 );
+      i+=highscore_intl( buf+i, addon_count(k_addon_type_board), 3 );
       buf[i++] = '\0';
 
       font3d_simple_draw( &gui.font, 0, buf, &main_camera, mmdl );
@@ -735,7 +576,7 @@ VG_STATIC void skateshop_render_worldshop(void)
    if( global_skateshop.render.world_reg != global_skateshop.selected_world_id){
       global_skateshop.render.world_title = "";
 
-      addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
+      addon_reg *reg = get_addon_from_index( k_addon_type_world,
                                        global_skateshop.selected_world_id );
       vg_msg root = {0};
       root.buf = reg->metadata;
@@ -756,15 +597,15 @@ VG_STATIC void skateshop_render_worldshop(void)
    vg_strnull( &info, buftext, 128 );
    vg_strnull( &subtext, bufsubtext, 128 );
    
-   if( addon_count(k_workshop_file_type_world) ){
-      addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
+   if( addon_count(k_addon_type_world) ){
+      addon_reg *reg = get_addon_from_index( k_addon_type_world,
                            global_skateshop.selected_world_id );
 
       info.i+=highscore_intl( info.buffer+info.i, 
                               global_skateshop.selected_world_id+1, 3 );
       info.buffer[info.i++] = '/';
       info.i+=highscore_intl( info.buffer+info.i, 
-                              addon_count(k_workshop_file_type_world), 3 );
+                              addon_count(k_addon_type_world), 3 );
       info.buffer[info.i++] = ' ';
       info.buffer[info.i] = '\0';
 
@@ -774,10 +615,10 @@ VG_STATIC void skateshop_render_worldshop(void)
          vg_strcat( &subtext, "Loading..." );
       }
       else{
-         addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
+         addon_reg *reg = get_addon_from_index( k_addon_type_world,
                                           global_skateshop.selected_world_id );
 
-         if( reg->workshop_id )
+         if( reg->alias.workshop_id )
             vg_strcat( &subtext, "(Workshop) " );
 
          vg_strcat( &subtext, global_skateshop.render.world_loc );
diff --git a/ent_skateshop.h b/ent_skateshop.h
index 70b327c..f64bd10 100644
--- a/ent_skateshop.h
+++ b/ent_skateshop.h
@@ -25,6 +25,7 @@ struct{
 
    u32 selected_world_id,
        selected_board_id,
+       selected_player_id,
        pointcloud_world_id;
 
    struct {
diff --git a/input.h b/input.h
index 6548eef..b4262bc 100644
--- a/input.h
+++ b/input.h
@@ -7,7 +7,6 @@
 #include "vg/vg_console.h"
 #include "vg/vg_input.h"
 #include "vg/vg_m.h"
-#include "conf.h"
 #include "font.h"
 
 enum sr_bind{
diff --git a/menu.h b/menu.h
index 4886843..b8f509e 100644
--- a/menu.h
+++ b/menu.h
@@ -5,7 +5,6 @@
 #include "model.h"
 #include "world_render.h"
 #include "player.h"
-#include "conf.h"
 #include "shaders/model_menu.h"
 #include "audio.h"
 #include "input.h"
diff --git a/models_src/ch_new.mdl b/models_src/ch_new.mdl
deleted file mode 100644
index aa3472f..0000000
Binary files a/models_src/ch_new.mdl and /dev/null differ
diff --git a/models_src/ch_none.mdl b/models_src/ch_none.mdl
new file mode 100644
index 0000000..f08ed10
Binary files /dev/null and b/models_src/ch_none.mdl differ
diff --git a/player.c b/player.c
index a5eaa08..1cca4ca 100644
--- a/player.c
+++ b/player.c
@@ -97,13 +97,12 @@ void player__use_avatar( player_instance *player, struct player_avatar *av )
    player_setup_ragdoll_from_avatar( &player->ragdoll, av );
 }
 
-#if 0
 PLAYER_API
-void player__use_model( player_instance *player, struct player_model *mdl )
-{
-   player->playermodel = mdl;
+void player__use_model( player_instance *player, u16 reg_id ){
+   addon_cache_unwatch( k_addon_type_player, player->playermodel_view_slot );
+   player->playermodel_view_slot = 
+      addon_cache_create_viewer( k_addon_type_player, reg_id );
 }
-#endif
 
 PLAYER_API
 void player__bind( player_instance *player )
diff --git a/player.h b/player.h
index 8f1e3c6..aba87e0 100644
--- a/player.h
+++ b/player.h
@@ -75,14 +75,7 @@ struct player_instance
 
    struct player_avatar  *playeravatar;
    struct player_ragdoll  ragdoll;
-
-#if 0
-   //struct player_model   *playermodel;
-   //struct player_board   *board;
-   
-   struct cache_board       *board_view_slot;
-   struct cache_playermodel *playermodel_view_slot;
-#endif
+   struct player_model    fallback_model;
 
    u16 board_view_slot, playermodel_view_slot;
 
@@ -230,6 +223,8 @@ PLAYER_API void player__use_avatar( player_instance *player,
                                     struct player_avatar *av );
 PLAYER_API void player__use_mesh( player_instance *player, glmesh *mesh );
 PLAYER_API void player__use_texture( player_instance *player, vg_tex2d *tex );
+PLAYER_API void player__use_model( player_instance *player, u16 reg_id );
+
 PLAYER_API void player__bind( player_instance *player );
 PLAYER_API void player__pre_update( player_instance *player );
 PLAYER_API void player__update( player_instance *player );
diff --git a/player_common.c b/player_common.c
index 8696eab..cb83d53 100644
--- a/player_common.c
+++ b/player_common.c
@@ -3,7 +3,6 @@
 
 #include "ent_skateshop.h"
 #include "player.h"
-#include "conf.h"
 #include "input.h"
 #include "menu.h"
 #include "vg/vg_perlin.h"
diff --git a/player_render.c b/player_render.c
index 17eb342..a039022 100644
--- a/player_render.c
+++ b/player_render.c
@@ -57,6 +57,11 @@ VG_STATIC void dynamic_model_load( mdl_context *ctx,
    mdl_async_load_glmesh( ctx, &mdl->mesh );
 }
 
+VG_STATIC void dynamic_model_unload( struct dynamic_model_1texture *mdl ){
+   mesh_free( &mdl->mesh );
+   glDeleteTextures( 1, &mdl->texture );
+}
+
 /* TODO: allow error handling */
 VG_STATIC void player_board_load( struct player_board *board, 
                                   const char *path ){
@@ -112,12 +117,23 @@ VG_STATIC void player_board_load( struct player_board *board,
    mdl_close( &ctx );
 }
 
-VG_STATIC void dynamic_model_unload( struct dynamic_model_1texture *mdl ){
-   mesh_free( &mdl->mesh );
-   glDeleteTextures( 1, &mdl->texture );
+VG_STATIC void player_board_unload( struct player_board *board ){
+   dynamic_model_unload( &board->mdl );
 }
 
-VG_STATIC void player_board_unload( struct player_board *board ){
+VG_STATIC void player_model_load( struct player_model *board, const char *path){
+   vg_linear_clear( vg_mem.scratch );
+
+   mdl_context ctx;
+   mdl_open( &ctx, path, vg_mem.scratch );
+   mdl_load_metadata_block( &ctx, vg_mem.scratch );
+
+   dynamic_model_load( &ctx, &board->mdl, path );
+
+   mdl_close( &ctx );
+}
+
+VG_STATIC void player_model_unload( struct player_model *board ){
    dynamic_model_unload( &board->mdl );
 }
 
@@ -153,7 +169,7 @@ VG_STATIC void player__pre_render( player_instance *player )
 
    struct player_avatar *av = player->playeravatar;
    struct player_board *board = 
-      addon_cache_item_if_loaded( k_workshop_file_type_board,
+      addon_cache_item_if_loaded( k_addon_type_board,
                                   player->board_view_slot );
 
    v3f vp0, vp1;
@@ -438,12 +454,14 @@ PLAYER_API void player__render( camera *cam, player_instance *player )
    SDL_AtomicLock( &addon_system.sl_cache_using_resources );
 
    struct player_model *model = 
-      addon_cache_item_if_loaded( k_workshop_file_type_player, 
+      addon_cache_item_if_loaded( k_addon_type_player, 
                                   player->playermodel_view_slot );
+
+   if( !model ) model = &player->fallback_model;
    render_playermodel( cam, world, model, &player->playeravatar->sk );
 
    struct player_board *board = 
-      addon_cache_item_if_loaded( k_workshop_file_type_board,
+      addon_cache_item_if_loaded( k_addon_type_board,
                                   player->board_view_slot );
    render_board( cam, world, board, player->playeravatar->sk.final_mtx[
                                        player->playeravatar->id_board],
diff --git a/player_render.h b/player_render.h
index 4d5145f..31fba37 100644
--- a/player_render.h
+++ b/player_render.h
@@ -66,12 +66,22 @@ enum board_shader{
    k_board_shader_entity
 };
 
+VG_STATIC void dynamic_model_load( mdl_context *ctx,
+                                   struct dynamic_model_1texture *mdl, 
+                                   const char *path );
+VG_STATIC void dynamic_model_unload( struct dynamic_model_1texture *mdl );
+
 VG_STATIC void player_board_load( struct player_board *mdl, const char *path );
 VG_STATIC void player_board_unload( struct player_board *mdl );
 
-VG_STATIC void dynamic_model_unload( struct dynamic_model_1texture *mdl );
+VG_STATIC void player_model_load( struct player_model *board, const char *path);
+VG_STATIC void player_model_unload( struct player_model *board );
+
 VG_STATIC void render_board( camera *cam, world_instance *world,
                              struct player_board *board, m4x3f root,
                              enum board_shader shader );
+VG_STATIC void render_playermodel( camera *cam, world_instance *world,
+                                   struct player_model *model,
+                                   struct skeleton *skeleton );
 
 #endif /* PLAYER_RENDER_H */
diff --git a/player_skate.c b/player_skate.c
index 3d01428..48d24bb 100644
--- a/player_skate.c
+++ b/player_skate.c
@@ -2997,7 +2997,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
       q_normalize( kf_board->q );
 
       struct player_board *board = 
-         addon_cache_item_if_loaded( k_workshop_file_type_board,
+         addon_cache_item_if_loaded( k_addon_type_board,
                                      player->board_view_slot );
       
       if( board ){
diff --git a/player_walk.c b/player_walk.c
index dbf0d02..45c2d0a 100644
--- a/player_walk.c
+++ b/player_walk.c
@@ -285,7 +285,7 @@ VG_STATIC void player__walk_pre_update( player_instance *player )
       }
       else{
          struct player_board *board = 
-            addon_cache_item_if_loaded( k_workshop_file_type_board,
+            addon_cache_item_if_loaded( k_addon_type_board,
                                         player->board_view_slot );
 
          if( !board ) return;
diff --git a/playermodels_src/skaterift_aaron/ch_aaron.mdl b/playermodels_src/skaterift_aaron/ch_aaron.mdl
new file mode 100644
index 0000000..70bc330
Binary files /dev/null and b/playermodels_src/skaterift_aaron/ch_aaron.mdl differ
diff --git a/playermodels_src/skaterift_chip/ch_chip.mdl b/playermodels_src/skaterift_chip/ch_chip.mdl
new file mode 100644
index 0000000..fec3896
Binary files /dev/null and b/playermodels_src/skaterift_chip/ch_chip.mdl differ
diff --git a/playermodels_src/skaterift_jordan/ch_jordan.mdl b/playermodels_src/skaterift_jordan/ch_jordan.mdl
index 67eea24..1113df0 100644
Binary files a/playermodels_src/skaterift_jordan/ch_jordan.mdl and b/playermodels_src/skaterift_jordan/ch_jordan.mdl differ
diff --git a/playermodels_src/skaterift_new/ch_new.mdl b/playermodels_src/skaterift_new/ch_new.mdl
index aa3472f..3e76b81 100644
Binary files a/playermodels_src/skaterift_new/ch_new.mdl and b/playermodels_src/skaterift_new/ch_new.mdl differ
diff --git a/playermodels_src/skaterift_outlaw/ch_outlaw.mdl b/playermodels_src/skaterift_outlaw/ch_outlaw.mdl
index 8bc115e..95ca052 100644
Binary files a/playermodels_src/skaterift_outlaw/ch_outlaw.mdl and b/playermodels_src/skaterift_outlaw/ch_outlaw.mdl differ
diff --git a/save.c b/save.c
index ad1b35e..40929d9 100644
--- a/save.c
+++ b/save.c
@@ -19,6 +19,38 @@ static void skaterift_write_savedata_thread(void *_){
    skaterift_end_op();
 }
 
+static void skaterift_write_viewslot( vg_msg *msg, const char *key,
+                                      enum addon_type type, u16 cache_id ){
+   if( !cache_id ) return;
+
+   struct addon_cache *cache = &addon_system.cache[type];
+   addon_cache_entry *entry = vg_pool_item( &cache->pool, cache_id );
+   addon_reg *reg = entry->reg_ptr;
+
+   if( reg ){
+      if( reg->alias.workshop_id ) 
+         vg_msg_wkvu64( msg, key, reg->alias.workshop_id );
+      else
+         vg_msg_wkvstr( msg, key, reg->alias.foldername );
+   }
+}
+
+static void skaterift_read_viewslot( vg_msg *msg, const char *key,
+                                     enum addon_type type, addon_alias *alias ){
+   
+   alias->foldername[0] = '\0';
+   alias->workshop_id = 0;
+   alias->type = type;
+
+   vg_msg_cmd kv = vg_msg_seekkv( msg, key, 0 );
+   if( kv.code == k_vg_msg_kvstring ){
+      vg_strncpy( kv.value, alias->foldername, sizeof(alias->foldername),
+                  k_strncpy_allow_cutoff );
+   }
+   else 
+      alias->workshop_id = vg_msg_read_as_u64( &kv );
+}
+
 static void skaterift_write_savedata(void){
    if( skaterift.async_op != k_async_op_none ) return;
 
@@ -30,19 +62,10 @@ static void skaterift_write_savedata(void){
 
    vg_msg_frame( &sav, "player" );
 
-   struct addon_cache *cache = &addon_system.cache[k_workshop_file_type_board];
-
-   if( localplayer.board_view_slot ){
-      addon_cache_entry *entry = vg_pool_item( &cache->pool, 
-                                               localplayer.board_view_slot );
-
-      if( entry->reg_ptr ){
-         if( entry->reg_ptr->workshop_id ) 
-            vg_msg_wkvu64( &sav, "board", entry->reg_ptr->workshop_id );
-         else
-            vg_msg_wkvstr( &sav, "board", entry->reg_ptr->foldername );
-      }
-   }
+   skaterift_write_viewslot( &sav, "board", k_addon_type_board, 
+                             localplayer.board_view_slot );
+   skaterift_write_viewslot( &sav, "playermodel", k_addon_type_player,
+                             localplayer.playermodel_view_slot );
 
    vg_msg_end_frame( &sav );
    savedata.len = sav.len;
diff --git a/shaders/model_board_view.h b/shaders/model_board_view.h
index 5b83ef2..437b1c4 100644
--- a/shaders/model_board_view.h
+++ b/shaders/model_board_view.h
@@ -412,7 +412,7 @@ static struct vg_shader _shader_model_board_view = {
 "{\n"
 "   compute_motion_vectors();\n"
 "\n"
-"   vec3 qnorm     = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);\n"
+"   vec3 qnorm     = aNorm;\n"
 "   vec3 diffuse   = texture( uTexMain, aUv ).rgb;\n"
 "   vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
 "\n"
diff --git a/shaders/model_character_view.fs b/shaders/model_character_view.fs
index afeb78d..5f9ee64 100644
--- a/shaders/model_character_view.fs
+++ b/shaders/model_character_view.fs
@@ -23,7 +23,7 @@ void main()
 {
    compute_motion_vectors();
 
-   vec3 qnorm     = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);
+   vec3 qnorm     = aNorm;
    vec3 diffuse   = texture( uTexMain, aUv ).rgb;
    vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );
 
diff --git a/shaders/model_character_view.h b/shaders/model_character_view.h
index cf93a55..55f8831 100644
--- a/shaders/model_character_view.h
+++ b/shaders/model_character_view.h
@@ -420,7 +420,7 @@ static struct vg_shader _shader_model_character_view = {
 "{\n"
 "   compute_motion_vectors();\n"
 "\n"
-"   vec3 qnorm     = normalize(floor(aNorm*2.0)*0.5) + vec3(0.001,0.0,0.0);\n"
+"   vec3 qnorm     = aNorm;\n"
 "   vec3 diffuse   = texture( uTexMain, aUv ).rgb;\n"
 "   vec3 composite = world_compute_lighting( diffuse, qnorm, aWorldCo, 1.0 );\n"
 "\n"
diff --git a/skaterift.c b/skaterift.c
index 8983f23..5d4e13f 100644
--- a/skaterift.c
+++ b/skaterift.c
@@ -21,7 +21,6 @@
  * --------------------- */
 
 #include "skaterift.h"
-#include "conf.h"
 #include "steam.h"
 #include "render.h"
 #include "audio.h"
@@ -76,7 +75,6 @@ VG_STATIC void vg_launch_opt(void)
 
 VG_STATIC void vg_preload(void)
 {
-   conf_init();
    skaterift_read_savedata();
 
 vg_info(" Copyright  .        . .       -----, ,----- ,---.   .---.  \n" );
@@ -114,12 +112,6 @@ VG_STATIC void load_playermodels(void)
    shader_model_entity_register();
 }
 
-void temp_update_playermodel(void){
-#if 0
-   player__use_model( &localplayer, &localplayer_models[k_playermdl_id] );
-#endif
-}
-
 VG_STATIC void async_skaterift_player_start( void *payload, u32 size )
 {
    localplayer.viewable_world = world_current_instance();
@@ -151,11 +143,9 @@ VG_STATIC void vg_load(void)
   
    /* player setup */
    player__create( &localplayer );
-   player_avatar_load( &localplayer_avatar, "models/ch_new.mdl" );
+   player_avatar_load( &localplayer_avatar, "models/ch_none.mdl" );
    player__use_avatar( &localplayer, &localplayer_avatar );
-#if 0
-   player__use_model( &localplayer, &localplayer_models[k_playermdl_id] );
-#endif
+   player_model_load( &localplayer.fallback_model, "models/ch_none.mdl" );
    player__bind( &localplayer );
 
    /* --------------------- */
@@ -178,7 +168,7 @@ VG_STATIC void vg_load(void)
 
    /* understate diy. */
    addon_reg *spawn = addon_mount_local_addon( "maps/mp_spawn", 
-                                                k_workshop_file_type_world, 
+                                                k_addon_type_world, 
                                                 ".mdl" );
    {
       vg_msg msg = {0};
@@ -193,7 +183,7 @@ VG_STATIC void vg_load(void)
 
    /* mtzero island */
    addon_reg *mtzero = addon_mount_local_addon( "maps/mp_mtzero",
-                                                k_workshop_file_type_world,
+                                                k_addon_type_world,
                                                 ".mdl" );
    {
       vg_msg msg = {0};
@@ -208,21 +198,20 @@ VG_STATIC void vg_load(void)
 
    global_skateshop.selected_world_id=1;
    global_skateshop.pointcloud_world_id=1;
-   skateshop_preview_loader_thread( mtzero ); /* HACK */
+   skateshop_world_preview_loader_thread( mtzero ); /* HACK */
 
    vg_async_call( async_addon_reg_update, NULL, 0 );
    vg_console_load_autos();
    menu_link();
-   temp_update_playermodel();
 
 	//vg_mem_log( vg_mem.rtmemory, 0, "Root" );
    
    vg_async_call( async_skaterift_player_start, NULL, 0 );
 
    skaterift_shift_op( k_async_op_board_scan );
-   addon_mount_content_folder( k_workshop_file_type_player, 
+   addon_mount_content_folder( k_addon_type_player, 
                                "playermodels", ".mdl" );
-   addon_mount_content_folder( k_workshop_file_type_board, "boards", ".mdl" );
+   addon_mount_content_folder( k_addon_type_board, "boards", ".mdl" );
    addon_mount_workshop_items();
    vg_async_call( async_addon_reg_update, NULL, 0 );
    vg_async_stall();
@@ -234,30 +223,26 @@ VG_STATIC void vg_load(void)
    sav.len = savedata.len;
    sav.max = sizeof(savedata.buf);
 
-   u64 query_workshop_id = 0;
-   const char *query_local_folder = "";
-
    if( vg_msg_seekframe(&sav, "player",0) ){
-      vg_msg_print( &sav );
-      vg_msg_cmd board = vg_msg_seekkv( &sav, "board", 0 );
-      if( board.code == k_vg_msg_kvstring )
-         query_local_folder = board.value;
-      else 
-         query_workshop_id = vg_msg_read_as_u64( &board );
-   }
-   else{
-      vg_error( "%u\n", sav.error );
-   }
+      addon_alias q;
+
+      /* board */
+      skaterift_read_viewslot( &sav, "board", k_addon_type_board, &q );
+      u32 reg_id = addon_match( &q );
+      if( reg_id != 0xffffffff ){
+         localplayer.board_view_slot = 
+            addon_cache_create_viewer( k_addon_type_board, reg_id );
+      }
 
-#if 0
-   vg_info( "search: %lu '%s'\n", query_workshop_id, query_local_folder );
-   u32 reg_id = addon_match( k_workshop_file_type_board,
-                             query_workshop_id, query_local_folder );
-   if( reg_id != 0xffffffff ){
-      localplayer.board_view_slot = skateshop_cache_fetch_board( reg_id );
-      vg_pool_watch( &addon_system.board_cache, localplayer.board_view_slot );
+      /* playermodel */
+      skaterift_read_viewslot( &sav, "playermodel", k_addon_type_player, &q );
+      reg_id = addon_match( &q );
+
+      if( reg_id == 0xffffffff ) reg_id = 0;
+
+      localplayer.playermodel_view_slot = 
+         addon_cache_create_viewer( k_addon_type_player, reg_id );
    }
-#endif
 
    board_processview_thread(NULL); /* END_OP!! */
 }
diff --git a/workshop.c b/workshop.c
index 1967e75..d0a3883 100644
--- a/workshop.c
+++ b/workshop.c
@@ -12,7 +12,6 @@
 #include "vg/vg_steam_auth.h"
 #include "vg/vg_steam_ugc.h"
 #include "vg/vg_steam_friends.h"
-#include "conf.h"
 #include "steam.h"
 #include "highscores.h"
 
@@ -24,9 +23,9 @@ static struct ui_dropdown_opt workshop_form_visibility_opts[] = {
 };
 
 static struct ui_dropdown_opt workshop_form_type_opts[] = {
- { "None",  k_workshop_file_type_none },
- { "Board", k_workshop_file_type_board },
- { "World", k_workshop_file_type_world },
+ { "None",  k_addon_type_none },
+ { "Board", k_addon_type_board },
+ { "World", k_addon_type_world },
 };
 
 /* 
@@ -60,9 +59,9 @@ VG_STATIC void workshop_reset_submission_data(void)
    workshop_form.submission.title[0] = '\0';
    workshop_form.submission.author[0] = '\0';
    workshop_form.submission.submission_type_selection.value = 
-      k_workshop_file_type_none;
+      k_addon_type_none;
    workshop_form.submission.submission_type_selection.index = 0;
-   workshop_form.submission.type = k_workshop_file_type_none;
+   workshop_form.submission.type = k_addon_type_none;
 
    workshop_form.submission.visibility.value = 
       k_ERemoteStoragePublishedFileVisibilityPublic;
@@ -189,10 +188,10 @@ VG_STATIC void workshop_form_upload_submission( PublishedFileId_t file_id,
       vg_strnull( &folder, path_buf, 4096 );
       vg_strcat( &folder, vg.base_path );
 
-      if( workshop_form.submission.type == k_workshop_file_type_board ){
+      if( workshop_form.submission.type == k_addon_type_board ){
          vg_strcat( &folder, "boards/" );
       }
-      else if( workshop_form.submission.type == k_workshop_file_type_world ){
+      else if( workshop_form.submission.type == k_addon_type_world ){
          vg_strcat( &folder, "maps/" );
       }
       vg_strcat( &folder, workshop_form.addon_folder );
@@ -303,10 +302,10 @@ VG_STATIC void _workshop_form_submit_thread( void *data )
    vg_str folder;
    vg_strnull( &folder, path_buf, 4096 );
 
-   if( workshop_form.submission.type == k_workshop_file_type_board ){
+   if( workshop_form.submission.type == k_addon_type_board ){
       vg_strcat( &folder, "boards/" );
    }
-   else if( workshop_form.submission.type == k_workshop_file_type_world ){
+   else if( workshop_form.submission.type == k_addon_type_world ){
       vg_strcat( &folder, "maps/" );
    }
    vg_strcat( &folder, workshop_form.addon_folder );
@@ -480,7 +479,7 @@ VG_STATIC void _workshop_form_load_thread( void *data )
    vg_str folder;
    vg_strnull( &folder, path_buf, 4096 );
 
-   if( workshop_form.submission.type == k_workshop_file_type_world )
+   if( workshop_form.submission.type == k_addon_type_world )
       vg_strcat( &folder, "maps/" );
    else vg_strcat( &folder, "boards/" );
 
@@ -536,7 +535,7 @@ VG_STATIC void _workshop_form_load_thread( void *data )
  */
 VG_STATIC void workshop_op_load_model(void)
 {
-   if( workshop_form.submission.type == k_workshop_file_type_world ){
+   if( workshop_form.submission.type == k_addon_type_world ){
       vg_warn( "WORLD LOAD INFO Currently unsupported\n" );
       return;
    }
@@ -690,10 +689,10 @@ VG_STATIC void workshop_op_download_and_view_submission( int result_index )
       workshop_form.file_intent = k_workshop_form_file_intent_keep_old;
       workshop_form.page = k_workshop_form_edit;
       workshop_form.submission.visibility.value = details.m_eVisibility;
-      workshop_form.submission.type = k_workshop_file_type_none;
+      workshop_form.submission.type = k_addon_type_none;
       workshop_form.submission.submission_type_selection.index = 0;
       workshop_form.submission.submission_type_selection.value = 
-         k_workshop_file_type_none;
+         k_addon_type_none;
 
       if( have_meta ){
          u32 len = strlen(metadata_str);
@@ -1062,13 +1061,13 @@ VG_STATIC void workshop_form_gui_page_undecided( ui_rect content ){
    ui_split_ratio( button_l, k_ui_axis_v, 0.5f, 2, button_l, button_r );
 
    if( workshop_form.submission.submission_type_selection.value !=
-         k_workshop_file_type_none ){
+         k_addon_type_none ){
       if( ui_button_text( button_l, "OK", 1 ) ){
-         enum workshop_file_type type = 
+         enum addon_type type = 
                workshop_form.submission.submission_type_selection.value;
          workshop_form.submission.type = type;
 
-         if( type == k_workshop_file_type_world ){
+         if( type == k_addon_type_world ){
             workshop_form.view_changed = 1;
             workshop_form.file_intent = k_workshop_form_file_intent_new;
          }
@@ -1087,14 +1086,14 @@ VG_STATIC void workshop_form_gui_page_undecided( ui_rect content ){
 }
 
 VG_STATIC void workshop_form_gui_draw_preview( ui_rect img_box ){
-   enum workshop_file_type type = workshop_form.submission.type;
+   enum addon_type type = workshop_form.submission.type;
    if( workshop_form.file_intent == k_workshop_form_file_intent_keep_old ){
       ui_image( img_box, gpipeline.fb_workshop_preview->attachments[0].id );
    }
    else if( workshop_form.file_intent == k_workshop_form_file_intent_new ){
       ui_image( img_box, gpipeline.fb_workshop_preview->attachments[0].id );
 
-      if( type == k_workshop_file_type_world ){
+      if( type == k_addon_type_world ){
          return;
       }
 
@@ -1154,9 +1153,9 @@ VG_STATIC void workshop_form_gui_draw_preview( ui_rect img_box ){
 }
 
 VG_STATIC void workshop_form_gui_edit_page( ui_rect content ){
-   enum workshop_file_type type = workshop_form.submission.type;
+   enum addon_type type = workshop_form.submission.type;
 
-   if( type == k_workshop_file_type_none ){
+   if( type == k_addon_type_none ){
       workshop_form_gui_page_undecided( content );
       return;
    }
@@ -1174,7 +1173,7 @@ VG_STATIC void workshop_form_gui_edit_page( ui_rect content ){
    ui_split( content, k_ui_axis_h, 8, 0, null, content );
    ui_split( content, k_ui_axis_h, 28, 0, file_entry, content );
 
-   if( workshop_form.submission.type == k_workshop_file_type_board ){
+   if( workshop_form.submission.type == k_addon_type_board ){
       ui_label( file_entry, "Addon folder: skaterift/boards/", 
                 1, 8, file_entry );
    }
@@ -1183,7 +1182,7 @@ VG_STATIC void workshop_form_gui_edit_page( ui_rect content ){
                 1, 8, file_entry );
    }
 
-   if( type == k_workshop_file_type_world ){
+   if( type == k_addon_type_world ){
       struct ui_textbox_callbacks callbacks = {
          .change = workshop_changed_model_path
       };
@@ -1323,7 +1322,7 @@ VG_STATIC void workshop_form_gui_sidebar( ui_rect sidebar )
       ui_text( title, "Editing", 1, k_ui_align_middle_center, 0 );
       ui_split( sidebar, k_ui_axis_h, 28, 0, title, sidebar );
 
-      if( workshop_form.submission.type != k_workshop_file_type_none ){
+      if( workshop_form.submission.type != k_addon_type_none ){
          char buf[512];
          vg_str str;
          vg_strnull( &str, buf, 512 );
@@ -1333,9 +1332,9 @@ VG_STATIC void workshop_form_gui_sidebar( ui_rect sidebar )
          else
             vg_strcat( &str, "Creating a new " );
 
-         if( workshop_form.submission.type == k_workshop_file_type_board )
+         if( workshop_form.submission.type == k_addon_type_board )
             vg_strcat( &str, "skateboard." );
-         else if( workshop_form.submission.type == k_workshop_file_type_world )
+         else if( workshop_form.submission.type == k_addon_type_world )
             vg_strcat( &str, "world." );
          else
             vg_strcat( &str, "???." );
@@ -1470,11 +1469,11 @@ VG_STATIC void workshop_form_gui(void)
        workshop_form.view_changed && 
        workshop_form.file_intent == k_workshop_form_file_intent_new )
    {
-      enum workshop_file_type type = workshop_form.submission.type;
-      if( type == k_workshop_file_type_board ){
+      enum addon_type type = workshop_form.submission.type;
+      if( type == k_addon_type_board ){
          workshop_render_board_preview();
       }
-      else if( type == k_workshop_file_type_world ){
+      else if( type == k_addon_type_world ){
          vg_success( "Renders world preview\n" );
          workshop_render_world_preview();
       }
diff --git a/workshop.h b/workshop.h
index 7751df0..d7c892f 100644
--- a/workshop.h
+++ b/workshop.h
@@ -1,9 +1,8 @@
 #ifndef WORKSHOP_H
 #define WORKSHOP_H
 
-#include "workshop_types.h"
-
 #define VG_GAME
+#include "addon_types.h"
 #include "vg/vg.h"
 #include "vg/vg_steam_remote_storage.h"
 #include "skaterift.h"
@@ -39,7 +38,7 @@ struct workshop_form{
       char description[512];
       char author[32];
       struct ui_dropdown_value submission_type_selection;
-      enum workshop_file_type type;
+      enum addon_type type;
 
       PublishedFileId_t file_id; /* 0 if not published yet */
 
diff --git a/workshop_types.h b/workshop_types.h
deleted file mode 100644
index b587ff4..0000000
--- a/workshop_types.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef WORKSHOP_TYPES_H
-#define WORKSHOP_TYPES_H
-
-enum workshop_file_type{
-   k_workshop_file_type_none   = 0,
-   k_workshop_file_type_board  = 1,
-   k_workshop_file_type_world  = 2,
-   k_workshop_file_type_player = 3,
-   k_workshop_file_type_max
-};
-
-#endif /* WORKSHOP_TYPES_H */
diff --git a/world_load.c b/world_load.c
index 448624e..1547d22 100644
--- a/world_load.c
+++ b/world_load.c
@@ -222,7 +222,8 @@ static void skaterift_change_world_preupdate(void)
 static void skaterift_change_world_start(void){
    if( world_loader.reg ){
       vg_info( "switching to %s ("PRINTF_U64"\n", 
-               world_loader.reg->foldername, world_loader.reg->workshop_id );
+               world_loader.reg->alias.foldername, 
+               world_loader.reg->alias.workshop_id );
    }
    else{
       vg_info( "switching to %s(local)\n", world_loader.override_name );
diff --git a/world_routes.c b/world_routes.c
index 56e6e4b..e83803c 100644
--- a/world_routes.c
+++ b/world_routes.c
@@ -774,7 +774,7 @@ VG_STATIC void world_write_preview( pointcloud_buffer *pcbuf ){
 
    if( world_loader.reg ){
       /* Don't want to override the one we get from the workshop */
-      if( world_loader.reg->workshop_id ) return;
+      if( world_loader.reg->alias.workshop_id ) return;
 
       addon_get_content_folder( world_loader.reg, &path );
    }