a more comprehensive workshop system

[carveJwlIkooP6JGAAIwe30JlM.git] / ent_skateshop.c

#ifndef ENT_SKATESHOP_C
#define ENT_SKATESHOP_C

#define VG_GAME
#include "vg/vg.h"
#include "vg/vg_steam_ugc.h"
#include "vg/vg_msg.h"
#include "ent_skateshop.h"
#include "world.h"
#include "player.h"
#include "gui.h"
#include "menu.h"
#include "pointcloud.h"
#include "highscores.h"
#include "steam.h"

/*
 * Checks string equality but does a hash check first
 */
static inline int const_str_eq( u32 hash, const char *str, const char *cmp )
{
   if( hash == vg_strdjb2(cmp) )
      if( !strcmp( str, cmp ) )
         return 1;
   return 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( u32 registry_index )
{
   struct registry_board *reg = NULL;

   if( registry_index < global_skateshop.registry_count ){
      reg = &global_skateshop.registry[ registry_index ];

      if( reg->cache_ptr ){
         return reg->cache_ptr;
      }
   }

   /* lru eviction. should be a linked list maybe... */
   double min_time = 1e300;
   struct cache_board *min_board = NULL;

   SDL_AtomicLock( &global_skateshop.sl_cache_access );
   for( u32 i=0; i<SKATESHOP_BOARD_CACHE_MAX; i++ ){
      struct cache_board *cache_ptr = &global_skateshop.cache[i];

      if( cache_ptr->state == k_cache_board_state_load_request ) continue;
      if( cache_ptr->ref_count ) continue;

      if( cache_ptr->last_use_time < min_time ){
         min_time = cache_ptr->last_use_time;
         min_board = cache_ptr;
      }
   }

   if( min_board ){
      if( min_board->state == k_cache_board_state_loaded ){
         struct registry_board *other = 
            &global_skateshop.registry[ min_board->registry_id ];

         vg_info( "Deallocating board: '%s'\n", min_board, other->foldername );

         player_board_unload( &min_board->board );
         other->cache_ptr = 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->registry_id = registry_index;
      min_board->last_use_time = vg.time;
      min_board->ref_count = 0;
      min_board->state = k_cache_board_state_load_request;
   }
   else{
      vg_error( "No free boards to load registry!\n" );
   }

   SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
   return min_board;
}

VG_STATIC void skateshop_update_viewpage(void)
{
   u32 page = global_skateshop.selected_registry_id/SKATESHOP_VIEW_SLOT_MAX;
   
   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;
      
      if( slot->cache_ptr ) unwatch_cache_board( slot->cache_ptr );

      slot->cache_ptr = skateshop_cache_fetch( request_id );
      if( slot->cache_ptr ) watch_cache_board( slot->cache_ptr );
   }
}

/*
 * op/subroutine: k_workshop_op_item_load
 * -----------------------------------------------------------------------------
 */

/*
 * Reciever for board completion; only promotes the status in the main thread
 */
VG_STATIC void skateshop_async_board_loaded( void *payload, u32 size )
{
   SDL_AtomicLock( &global_skateshop.sl_cache_access );
   struct cache_board *cache_ptr = payload;
   cache_ptr->last_use_time = vg.time;
   cache_ptr->state = k_cache_board_state_loaded;

   struct registry_board *reg = 
      &global_skateshop.registry[ cache_ptr->registry_id ];
   reg->cache_ptr = cache_ptr;
   SDL_AtomicUnlock( &global_skateshop.sl_cache_access );

   vg_success( "Async board loaded (%s)\n", reg->foldername );
}

/*
 * 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_thread( void *_args )
{
   char path_buf[4096];
   vg_str folder;

   for( u32 i=0; i<SKATESHOP_BOARD_CACHE_MAX; i++ ){
      struct cache_board *cache_ptr = &global_skateshop.cache[i];

      SDL_AtomicLock( &global_skateshop.sl_cache_access );
      if( cache_ptr->state == k_cache_board_state_load_request ){
         if( cache_ptr->registry_id >= global_skateshop.registry_count ){
            /* should maybe have a different value for this case */
            cache_ptr->state = k_cache_board_state_none;
            SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
            continue;
         }

         /* continue with the request */
         SDL_AtomicUnlock( &global_skateshop.sl_cache_access );

         struct registry_board *reg = 
            &global_skateshop.registry[ cache_ptr->registry_id ];

         if( reg->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 = path_buf;
            info->id = reg->workshop_id;
            info->len = vg_list_size(path_buf);
            vg_async_dispatch( call, async_workshop_get_filepath );
            vg_async_stall(); /* too bad! */

            if( path_buf[0] == '\0' ){
               vg_error( "Failed SteamAPI_GetItemInstallInfo(" PRINTF_U64 ")\n",
                           reg->workshop_id );

               goto file_is_broken;
            }

            folder.buffer = path_buf;
            folder.i = strlen(path_buf);
            folder.len = 4096;
         }
         else{
            vg_strnull( &folder, path_buf, 4096 );
            vg_strcat( &folder, "boards/" );
            vg_strcat( &folder, reg->foldername );
         }

         vg_str meta_path = folder;
         vg_strcat( &meta_path, "/addon.inf" );

         if( !vg_strgood( &meta_path ) ) {
            vg_error( "Metadata path too long\n" );
            goto file_is_broken;
         }

         u8 meta[512];
         FILE *fp = fopen( meta_path.buffer, "rb" );

         if( !fp ) goto file_is_broken;

         u32 l = fread( meta, 1, 512, fp );
         if( l != 512 ){
            if( !feof(fp) ){
               fclose(fp);
               vg_error( "unknown error codition" );
               goto file_is_broken;
            }
         }
         fclose(fp);

         /* load content files
          * --------------------------------- */

         vg_str content_path = folder;

         vg_msg msg;
         vg_msg_init( &msg, meta, l );
         vg_msg_cmd cmd;
         while( vg_msg_next( &msg, &cmd ) ){
            if( (msg.depth == 0) && (cmd.code == k_vg_msg_code_kvstring) ){
               if( VG_STRDJB2_EQ( "content", cmd.key, cmd.key_djb2 ) ){
                  vg_strcat( &content_path, "/" );
                  vg_strcat( &content_path, cmd.value._buf );
                  break;
               }
            }
         }
         if( !vg_strgood( &content_path ) ) {
            vg_error( "Metadata path too long\n" );
            goto file_is_broken;
         }

         player_board_load( &cache_ptr->board, content_path.buffer );
         vg_async_call( skateshop_async_board_loaded, cache_ptr, 0 );
         continue;

file_is_broken:;
         SDL_AtomicLock( &global_skateshop.sl_cache_access );
         cache_ptr->state = k_cache_board_state_none;
         SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
      }
      else
         SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
   }
   vg_async_call( workshop_async_any_complete, NULL, 0 );
}

/*
 * op: k_workshop_op_item_scan
 * -----------------------------------------------------------------------------
 */

/*
 * Reciever for scan completion. copies the registry_count back into t0
 */
VG_STATIC void workshop_async_reg_update( void *data, u32 size )
{
   vg_info( "Registry update notify\n" );
   global_skateshop.registry_count = global_skateshop.t1_registry_count;
}

VG_STATIC void workshop_steam_scan(void)
{
   /*
    * Steam workshop scan
    */
   vg_info( "Scanning steam workshop for boards\n" );
   PublishedFileId_t workshop_ids[ SKATESHOP_REGISTRY_MAX ];
   u32 workshop_count = SKATESHOP_REGISTRY_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<global_skateshop.t1_registry_count; i++ ){
         struct registry_board *reg = &global_skateshop.registry[i];

         if( reg->workshop_id == id ){
            reg->state = k_registry_board_state_indexed;
            goto next_file_workshop;
         }
      }
      for( u32 i=0; i<global_skateshop.t1_world_registry_count; i++ ){
         struct registry_world *reg = &global_skateshop.world_registry[i];

         if( reg->workshop_id == id ){
            reg->state = k_registry_board_state_indexed;
            goto next_file_workshop;
         }
      }

      /* new one, lets find out what type it is
       * ---------------------------------------------------------------*/
      vg_info( "new listing from the steam workshop!: "PRINTF_U64"\n", id );
      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_info( "%s\n", path );
      vg_str folder = {.buffer = path, .i=strlen(path), .len=4096};
      vg_str meta_path = folder;
      vg_strcat( &meta_path, "/addon.inf" );
      if( !vg_strgood( &meta_path ) ){
         vg_error( "The metadata path is too long\n" );
         goto next_file_workshop;
      }

      u8 meta[512];
      FILE *fp = fopen( meta_path.buffer, "rb" );
      if( !fp ){
         vg_error( "Could not open the '%s'\n", meta_path.buffer );
         goto next_file_workshop;
      }

      u32 l = fread( meta, 1, 512, fp );
      if( l != 512 ){
         if( !feof(fp) ){
            fclose(fp);
            vg_error( "unknown error codition" );
            goto next_file_workshop;
         }
      }
      fclose(fp);

      enum workshop_file_type type = k_workshop_file_type_none;
      vg_msg msg;
      vg_msg_init( &msg, meta, l );

      vg_msg_cmd cmd;
      while( vg_msg_next( &msg, &cmd ) ){
         if( (msg.depth == 1) && (cmd.code == k_vg_msg_code_frame) ){
            if( VG_STRDJB2_EQ( "workshop", cmd.key, cmd.key_djb2 ) ){
               u32 depth = msg.depth;
               while( (msg.depth == depth) && vg_msg_next( &msg, &cmd ) ){
                  if( cmd.code & k_vg_msg_code_unsigned ){
                     if( VG_STRDJB2_EQ( "type", cmd.key, cmd.key_djb2 ) ){
                        type = cmd.value._u32;
                     }
                  }
               }
            }
         }
      }

      if( type == k_workshop_file_type_none ){
         vg_error( "Cannot determine addon type\n" );
         goto next_file_workshop;
      }

      /* now that we have the type
       * ------------------------------------------------------------------*/

      if( type == k_workshop_file_type_board ){
         if( global_skateshop.t1_registry_count == SKATESHOP_REGISTRY_MAX ){
            vg_error( "You have too many boards installed!\n" );
            goto next_file_workshop;
         }

         struct registry_board *reg = &global_skateshop.registry[
                                       global_skateshop.t1_registry_count ++ ];

         reg->cache_ptr = NULL;
         snprintf( reg->foldername, 64, PRINTF_U64, id );
         reg->foldername_hash = vg_strdjb2( reg->foldername );
         reg->workshop_id = id;
         reg->state = k_registry_board_state_indexed;
      }
      else if( type == k_workshop_file_type_world ){
         if( global_skateshop.t1_world_registry_count == SKATESHOP_WORLDS_MAX ){
            vg_error( "You have too many worlds installed!\n" );
            goto next_file_workshop;
         }

         struct registry_world *reg = &global_skateshop.world_registry[
                                 global_skateshop.t1_world_registry_count ++ ];
         
         snprintf( reg->foldername, 64, PRINTF_U64, id );
         reg->foldername_hash = vg_strdjb2( reg->foldername );
         reg->type = k_world_load_type_workshop;
         reg->workshop_id = id;
         reg->state = k_registry_board_state_indexed;
      }

next_file_workshop:;
   }
}

/*
 * Async thread which scans local files for boards, as well as scheduling 
 * synchronous calls to the workshop
 */
VG_STATIC void workshop_scan_thread( void *_args )
{
   vg_linear_clear( vg_mem.scratch );

   for( u32 i=0; i<global_skateshop.t1_registry_count; i++ ){
      struct registry_board *reg = &global_skateshop.registry[i];
      reg->state = k_registry_board_state_indexed_absent;
   }

#if 0
   /*
    * Local disk scan
    */
   vg_info( "Scanning models/boards/*.mdl\n" );
   tinydir_dir dir;
   tinydir_open( &dir, "models/boards" );

   while( dir.has_next ){
      tinydir_file file;
      tinydir_readfile( &dir, &file );
      
      if( file.is_reg ){
         u32 hash = vg_strdjb2( file.name );

         for( u32 i=0; i<global_skateshop.t1_registry_count; i++ ){
            struct registry_board *reg = &global_skateshop.registry[i];

            if( const_str_eq( hash, file.name, reg->filename ) ){
               reg->state = k_registry_board_state_indexed;
               goto next_file;
            }
         }

         if( global_skateshop.t1_registry_count == SKATESHOP_REGISTRY_MAX ){
            vg_error( "You have too many boards installed!\n" );
            break;
         }

         vg_info( "new listing!: %s\n", file.name );

         struct registry_board *reg = 
            &global_skateshop.registry[global_skateshop.t1_registry_count ++];

         reg->cache_ptr = NULL;
         vg_strncpy( file.name, reg->filename, 64, k_strncpy_always_add_null );
#if 0
         vg_strncpy( file.name, reg->workshop.title,
                     64, k_strncpy_always_add_null );
#endif
         reg->filename_hash = hash;
         reg->workshop_id = 0;
         reg->state = k_registry_board_state_indexed;

#if 0
         reg->workshop.author = 0;
         strcpy( reg->workshop.author_name, "custom" );
#endif
      }

next_file: tinydir_next( &dir );
   }

   tinydir_close(&dir);
#endif

   if( steam_ready ) workshop_steam_scan();
   
   vg_async_call( workshop_async_reg_update, NULL, 0 );
   vg_async_stall();
   workshop_visibile_load_loop_thread(NULL);
}

/*
 * Asynchronous scan of local disk for items and add them to the registry
 */
VG_STATIC void workshop_op_item_scan(void)
{
   skaterift_begin_op( k_workshop_op_item_scan );
   vg_loader_start( workshop_scan_thread, NULL );
}

/*
 * op: k_async_op_world_scan
 * -----------------------------------------------------------------------------
 */

/*
 * Reciever for scan completion. copies the registry_count back into t0
 */
VG_STATIC void workshop_async_world_reg_update( void *data, u32 size )
{
   vg_info( "World registry update notify\n" );
   global_skateshop.world_registry_count = 
      global_skateshop.t1_world_registry_count;
   skaterift_end_op();
}

/*
 * Add a local world folder to the registry, it will verify existing ones are 
 * still there too.
 */
VG_STATIC void world_scan_register_local( const char *folder_name )
{
   u32 hash = vg_strdjb2( folder_name );
   for( u32 i=0; i<global_skateshop.t1_world_registry_count; i++ ){
      struct registry_world *reg = 
         &global_skateshop.world_registry[i];

      if( const_str_eq( hash, folder_name, reg->foldername ) ){
         reg->state = k_registry_board_state_indexed;
         return;
      }
   }

   if( global_skateshop.t1_world_registry_count == SKATESHOP_WORLDS_MAX ){
      vg_error( "You have too many worlds installed!\n" );
      return;
   }

   vg_info( "new listing!: %s\n", folder_name );

   struct registry_world *reg = &global_skateshop.world_registry[
      global_skateshop.t1_world_registry_count ++ ];

   vg_strncpy( folder_name, reg->foldername, 64, k_strncpy_overflow_fatal );
   reg->foldername_hash = hash;
   reg->state = k_registry_board_state_indexed;
   //reg->meta_present = 0;
   reg->type = k_world_load_type_local;
}

/*
 * Async thread which scans local files for boards, as well as scheduling 
 * synchronous calls to the workshop
 */
VG_STATIC void world_scan_thread( void *_args )
{
   vg_linear_clear( vg_mem.scratch );

   for( u32 i=0; i<global_skateshop.t1_world_registry_count; i++ ){
      struct registry_world *reg = &global_skateshop.world_registry[i];
      reg->state = k_registry_board_state_indexed_absent;
   }

   /*
    * Local disk scan
    */
   vg_info( "Scanning maps/*.mdl\n" );

   char path_buf[4096];
   vg_str path;
   vg_strnull( &path, path_buf, 4096 );
   vg_strcat( &path, "maps/" );

   DIR *dir = opendir( path.buffer );
   if( !dir ){
      vg_error( "opendir('maps') failed\n" );
      vg_async_call( workshop_async_any_complete, NULL, 0 );
      return;
   }

   struct dirent *entry;
   while( (entry = readdir(dir)) ){
      if( entry->d_type == DT_DIR ){
         if( entry->d_name[0] == '.' ) continue;

         vg_str folder = path;
         char *folder_name = folder.buffer+folder.i;

         if( strlen( entry->d_name ) >
               vg_list_size(global_skateshop.world_registry[0].foldername)){
            vg_warn( "Map folder too long: %s\n", entry->d_name );
            continue;
         }

         vg_strcat( &folder, entry->d_name );
         if( !vg_strgood( &folder ) ) break;

         DIR *subdir = opendir( folder.buffer );
         while( (entry = readdir(subdir)) ){
            if( entry->d_type == DT_REG ){
               if( entry->d_name[0] == '.' ) continue;

               vg_str file = folder;
               vg_strcat( &file, "/" );
               vg_strcat( &file, entry->d_name );
               if( !vg_strgood( &file ) ) continue;

               char *ext = vg_strch( &file, '.' );
               if( !ext ) continue;
               if( strcmp(ext,".mdl") ) continue;
               
               vg_strcat( &folder, "" );
               world_scan_register_local( folder_name );
            }
         }
         closedir(subdir);
      }
   }
   closedir(dir);

   vg_async_call( workshop_async_world_reg_update, NULL, 0 );

#if 0
   tinydir_close(&dir);

   if( steam_ready ) workshop_steam_scan();
   
   vg_async_call( workshop_async_reg_update, NULL, 0 );
   vg_async_stall();
   workshop_visibile_load_loop_thread(NULL);
#endif
}

/*
 * Asynchronous scan of local disk for worlds
 */
VG_STATIC void skateshop_op_world_scan(void)
{
   skaterift_begin_op( k_async_op_world_scan );
   vg_loader_start( world_scan_thread, NULL );
}

/*
 * Regular stuff
 * -----------------------------------------------------------------------------
 */

/* we can only keep using a viewslot pointer for multiple frames if we watch it
 * using this function */
VG_STATIC void watch_cache_board( struct cache_board *ptr )
{
   if( ptr->ref_count >= 32 ){
      vg_fatal_error( "dynamic board watch missmatch (limit is 32)\n" );
   }

   ptr->last_use_time = vg.time;
   ptr->ref_count ++;
}

/* after this is called, the calling code only has access to the pointer for the
 * duration of the rest of the frame */
VG_STATIC void unwatch_cache_board( struct cache_board *ptr )
{
   if( ptr->ref_count == 0 ){
      vg_fatal_error( "dynamic board unwatch missmatch (no watchers)\n" );
   }

   ptr->ref_count --;
}

/*
 * Callback handler for persona state changes,
 * it sets the author names on the registries
 */
VG_STATIC void callback_persona_statechange( CallbackMsg_t *msg )
{
   PersonaStateChange_t *info = (PersonaStateChange_t *)msg->m_pubParam;
   ISteamFriends *hSteamFriends = SteamAPI_SteamFriends();

#if 0
   if( info->m_nChangeFlags & k_EPersonaChangeName ){
      for( u32 i=0; i<global_skateshop.registry_count; i++ ){
         struct registry_board *reg = &global_skateshop.registry[i];
         if( reg->workshop.author == info->m_ulSteamID ){
            const char *name = SteamAPI_ISteamFriends_GetFriendPersonaName( 
                                    hSteamFriends, info->m_ulSteamID );
            str_utf8_collapse( name, reg->workshop.author_name, 32 );
         }
      }
   }
#endif
}

/*
 * VG event init
 */
VG_STATIC void skateshop_init(void)
{
   u32 reg_size   = sizeof(struct registry_board)*SKATESHOP_REGISTRY_MAX,
       wreg_size  = sizeof(struct registry_world)*SKATESHOP_WORLDS_MAX,
       cache_size = sizeof(struct cache_board)*SKATESHOP_BOARD_CACHE_MAX;
   
   global_skateshop.registry = vg_linear_alloc( vg_mem.rtmemory, reg_size );
   global_skateshop.world_registry = 
      vg_linear_alloc( vg_mem.rtmemory, wreg_size );
   global_skateshop.cache = vg_linear_alloc( vg_mem.rtmemory, cache_size );

   memset( global_skateshop.cache, 0, cache_size );

   for( u32 i=0; i<SKATESHOP_BOARD_CACHE_MAX; i++ ){
      struct cache_board *board = &global_skateshop.cache[i];
      board->state = k_cache_board_state_none;
      board->registry_id = 0xffffffff;
      board->last_use_time = -99999.9;
      board->ref_count = 0;
   }

   if( steam_ready ){
      steam_register_callback( k_iPersonaStateChange, 
                               callback_persona_statechange );
   }
}

VG_STATIC struct cache_board *skateshop_selected_cache_if_loaded(void)
{
   if( global_skateshop.registry_count > 0 ){
      u32 reg_id = global_skateshop.selected_registry_id;
      struct registry_board *reg = &global_skateshop.registry[ reg_id ];

      SDL_AtomicLock( &global_skateshop.sl_cache_access );
      if( reg->cache_ptr && 
         (reg->cache_ptr->state == k_cache_board_state_loaded ) )
      {
         SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
         return reg->cache_ptr;
      }
      SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
   }

   return NULL;
}

VG_STATIC void pointcloud_async_end(void *_, u32 __)
{
   pointcloud_animate( k_pointcloud_anim_opening );
   skaterift_end_op();
}

VG_STATIC void pointcloud_clear_async(void *_, u32 __)
{
   pointcloud.count = 0;
   pointcloud_animate( k_pointcloud_anim_opening );
   skaterift_end_op();
}

VG_STATIC void skateshop_preview_loader_thread( void *_data )
{
   struct registry_world *reg = _data;
   
   if( reg->type == k_world_load_type_local ){
      char path_buf[4096];
      vg_str path;
      vg_strnull( &path, path_buf, 4096 );
      vg_strcat( &path, "maps/" );
      vg_strcat( &path, reg->foldername );
      vg_strcat( &path, "/preview.bin" );

      vg_linear_clear(vg_mem.scratch);
      u32 size;
      
      void *data = vg_file_read( vg_mem.scratch, path_buf, &size );
      if( data ){
         if( size < sizeof(pointcloud_buffer) ){
            vg_async_call( pointcloud_clear_async, NULL, 0 );
            return;
         }
         
         vg_async_item *call = vg_async_alloc(size);
         pointcloud_buffer *pcbuf = call->payload;
         memcpy( pcbuf, data, size );

         u32 point_count = (size-sizeof(pointcloud_buffer)) /
                              sizeof(struct pointcloud_vert);
         pcbuf->max = point_count;
         pcbuf->count = point_count;
         pcbuf->op = k_pointcloud_op_clear;

         vg_async_dispatch( call, async_pointcloud_sub );
         vg_async_call( pointcloud_async_end, NULL, 0 );
      }
      else{
         vg_async_call( pointcloud_clear_async, NULL, 0 );
      }
   }
   else{
      vg_async_call( pointcloud_clear_async, NULL, 0 );
   }
}

VG_STATIC void skateshop_load_world_preview( struct registry_world *reg )
{
   skaterift_begin_op( k_async_op_world_load_preview );
   vg_loader_start( skateshop_preview_loader_thread, reg );
}

/*
 * VG event preupdate 
 */
void temp_update_playermodel(void);
VG_STATIC void global_skateshop_preupdate(void)
{
   float rate = vg_minf( 1.0f, vg.time_frame_delta * 2.0f );
   global_skateshop.factive = vg_lerpf( global_skateshop.factive, 
                                        global_skateshop.active, rate );

   if( !global_skateshop.active ) return;

   world_instance *world = world_current_instance();
   ent_skateshop *shop = global_skateshop.ptr_ent;

   /* camera positioning */
   ent_camera *ref = mdl_arritm( &world->ent_camera, 
                                 mdl_entity_id_id(shop->id_camera) );
      
   v3f dir = {0.0f,-1.0f,0.0f};
   mdl_transform_vector( &ref->transform, dir, dir );
   m3x3_mulv( localplayer.invbasis, dir, dir );
   player_vector_angles( localplayer.cam_override_angles, dir, 1.0f, 0.0f );

   v3f lookat;
   if( shop->type == k_skateshop_type_boardshop ||
       shop->type == k_skateshop_type_worldshop ){
      ent_marker *display = mdl_arritm( &world->ent_marker,
                                    mdl_entity_id_id(shop->boards.id_display) );
      
      v3_sub( display->transform.co, localplayer.rb.co, lookat );
      
   }
   else if( shop->type == k_skateshop_type_charshop ){
      v3_sub( ref->transform.co, localplayer.rb.co, lookat );
   }
   else{
      vg_fatal_error( "Unknown store (%u)\n", shop->type );
   }

   q_axis_angle( localplayer.rb.q, (v3f){0.0f,1.0f,0.0f}, 
                 atan2f(lookat[0],lookat[2]) );

   v3_copy( ref->transform.co, localplayer.cam_override_pos );
   localplayer.cam_override_fov = ref->fov;
   localplayer.cam_override_strength = global_skateshop.factive;

   /* input */
   if( shop->type == k_skateshop_type_boardshop ){
      gui_helper_action( axis_display_string( k_sraxis_mbrowse_h ), "browse" );
      gui_helper_action( button_display_string( k_srbind_mback ), "exit" );

      struct cache_board *selected_cache = skateshop_selected_cache_if_loaded();

      if( selected_cache ){
         gui_helper_action( button_display_string( k_srbind_maccept ), "pick" );
      }

      /*
       * Controls
       * ----------------------
       */

      if( button_down( k_srbind_mleft ) ){
         if( global_skateshop.selected_registry_id > 0 ){
            global_skateshop.selected_registry_id --;
         }
      }

      if( button_down( k_srbind_mright ) ){
         if( global_skateshop.selected_registry_id+1 < 
                  global_skateshop.registry_count )
         {
            global_skateshop.selected_registry_id ++;
         }
      }

      if( selected_cache && button_down( k_srbind_maccept ) ){
         vg_info( "chose board from skateshop (%u)\n", 
                     global_skateshop.selected_registry_id );

         if( localplayer.board_view_slot ){
            unwatch_cache_board( localplayer.board_view_slot );
         }

         localplayer.board_view_slot = selected_cache;
         watch_cache_board( localplayer.board_view_slot );

         global_skateshop_exit();
         return;
      }
   }
   else if( shop->type == k_skateshop_type_charshop ){
      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" );

      if( button_down( k_srbind_mleft ) ){
         if( cl_playermdl_id > 0 ){
            cl_playermdl_id --;
         }
         else{
            cl_playermdl_id = 2; /* HACK */
         }
         temp_update_playermodel(); /* HACK */
      }

      if( button_down( k_srbind_mright ) ){
         if( cl_playermdl_id+1 < 3 ){
            cl_playermdl_id ++;
         }
         else{
            cl_playermdl_id = 0;  /* HACK */
         }
         temp_update_playermodel(); /* HACK */
         /*lol*/
      }

      if( button_down( k_srbind_maccept ) ){
         global_skateshop_exit();
      }
   }
   else if( shop->type == k_skateshop_type_worldshop ){
      int browseable = 0,
          loadable = 0;

      if( global_skateshop.world_registry_count &&
            ((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" );
         browseable = 1;
      }

      if( skaterift.async_op == k_async_op_none ){
         gui_helper_action( button_display_string(k_srbind_maccept), "load" );
         loadable = 1;
      }
      
      int change = 0;

      if( browseable ){
         if( button_down( k_srbind_mleft ) ){
            if( global_skateshop.selected_world_id > 0 )
            {
               global_skateshop.selected_world_id --;
               change = 1;
            }
         }

         if( button_down( k_srbind_mright ) ){
            if( global_skateshop.selected_world_id+1 < 
                     global_skateshop.world_registry_count )
            {
               global_skateshop.selected_world_id ++;
               change = 1;
            }
         }
      }
      
      if( change && pointcloud_idle() ){
         pointcloud_animate( k_pointcloud_anim_hiding );
      }

      if( skaterift.async_op == k_async_op_none ){
         struct registry_world *rw = &global_skateshop.world_registry[
            global_skateshop.selected_world_id ];

         /* automatically load in clouds */
         if( loadable && button_down( k_srbind_maccept ) ){
            vg_info( "Select world (%u)\n", 
                      global_skateshop.selected_world_id );
            skaterift_change_world( rw->foldername );
            return;
         }
         else{
            if( pointcloud.anim == k_pointcloud_anim_idle_closed ){
               if( global_skateshop.pointcloud_world_id !=
                     global_skateshop.selected_world_id )
               {
                  global_skateshop.pointcloud_world_id = 
                     global_skateshop.selected_world_id;
                  skateshop_load_world_preview( rw );
               }
               else{
                  pointcloud_animate( k_pointcloud_anim_opening );
               }
            }
            else if( pointcloud.anim == k_pointcloud_anim_idle_open ){
               if( global_skateshop.pointcloud_world_id !=
                     global_skateshop.selected_world_id )
               {
                  pointcloud_animate( k_pointcloud_anim_hiding );
               }
            }
         }
      }
   }
   else{
      vg_fatal_error( "Unknown store (%u)\n", shop->type );
   }

   if( button_down( k_srbind_mback ) ){
      global_skateshop_exit();
      return;
   }
}

VG_STATIC void skateshop_render_boardshop(void)
{
   world_instance *world = world_current_instance();
   ent_skateshop *shop = global_skateshop.ptr_ent;

   u32 slot_count = vg_list_size(global_skateshop.shop_view_slots);

   ent_marker *mark_rack = mdl_arritm( &world->ent_marker, 
                                  mdl_entity_id_id(shop->boards.id_rack)),
              *mark_display = mdl_arritm( &world->ent_marker,
                                  mdl_entity_id_id(shop->boards.id_display));

   int visibility[ SKATESHOP_VIEW_SLOT_MAX ];
   SDL_AtomicLock( &global_skateshop.sl_cache_access );
   for( u32 i=0; i<SKATESHOP_VIEW_SLOT_MAX; i++ ){
      struct shop_view_slot *slot = &global_skateshop.shop_view_slots[i];

      visibility[i] = 1;

      if( slot->cache_ptr == NULL ) visibility[i] = 0;
      else if( slot->cache_ptr->state != k_cache_board_state_loaded )
         visibility[i] = 0;
   }
   SDL_AtomicUnlock( &global_skateshop.sl_cache_access );
   
   /* Render loaded boards in the view slots */
   for( u32 i=0; i<slot_count; i++ ){
      struct shop_view_slot *slot = &global_skateshop.shop_view_slots[i];
      float selected = 0.0f;

      if( !visibility[i] ) goto fade_out;

      mdl_transform xform;
      transform_identity( &xform );

      xform.co[0] = -((float)i - ((float)slot_count)*0.5f)*0.45f;
      mdl_transform_mul( &mark_rack->transform, &xform, &xform );

      if( slot->cache_ptr->registry_id == 
          global_skateshop.selected_registry_id ){
         selected = 1.0f;
      }

      float t = slot->view_blend;
      v3_lerp( xform.co, mark_display->transform.co, t, xform.co );
      q_nlerp( xform.q, mark_display->transform.q, t, xform.q );
      v3_lerp( xform.s, mark_display->transform.s, t, xform.s );

      m4x3f mmdl;
      mdl_transform_m4x3( &xform, mmdl );
      render_board( &main_camera, world, &slot->cache_ptr->board, mmdl,
                    k_board_shader_entity );

fade_out:;
      float rate = 5.0f*vg.time_delta;
      slot->view_blend = vg_lerpf( slot->view_blend, selected, rate );
   }

   ent_marker *mark_info = mdl_arritm( &world->ent_marker, 
                                        mdl_entity_id_id(shop->boards.id_info));
   m4x3f mtext, mrack;
   mdl_transform_m4x3( &mark_info->transform, mtext );
   mdl_transform_m4x3( &mark_rack->transform, mrack );

#if 0
   const char *text_title = "Fish - Title";
   const char *text_author = "by Shaniqua";
#endif

   m4x3f mlocal, mmdl;
   m4x3_identity( mlocal );

   float scale = 0.2f,
         thickness = 0.03f;

   font3d_bind( &gui.font, &main_camera );
   shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );

   /* Selection counter
    * ------------------------------------------------------------------ */
   m3x3_zero( mlocal );
   v3_zero( mlocal[3] );
   mlocal[0][0] = -scale*2.0f;
   mlocal[1][2] = -scale*2.0f;
   mlocal[2][1] = -thickness;
   mlocal[3][2] = -0.7f;
   m4x3_mul( mrack, mlocal, mmdl );

   if( global_skateshop.registry_count == 0 ){
      font3d_simple_draw( &gui.font, 0, 
                          "Nothing installed", &main_camera, mmdl );
   }
   else{
      char buf[16];
      int i=0;
      i+=highscore_intl( buf+i, global_skateshop.selected_registry_id+1, 3 );
      buf[i++] = '/';
      i+=highscore_intl( buf+i, global_skateshop.registry_count, 3 );
      buf[i++] = '\0';

      font3d_simple_draw( &gui.font, 0, buf, &main_camera, mmdl );
   }

   struct cache_board *cache_ptr = skateshop_selected_cache_if_loaded();
   if( !cache_ptr ) return;

   struct registry_board *reg = 
      &global_skateshop.registry[cache_ptr->registry_id];

#if 0
   struct workshop_file_info *info = &reg->workshop;

   /* Skin title
    * ----------------------------------------------------------------- */
   m3x3_zero( mlocal );
   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width( &gui.font, 0, info->title );
   mlocal[3][0] *= scale*0.5f;
   mlocal[3][1] = 0.1f;
   mlocal[3][2] = 0.0f;
   m4x3_mul( mtext, mlocal, mmdl );
   font3d_simple_draw( &gui.font, 0, info->title, &main_camera, mmdl );

   /* Author name
    * ----------------------------------------------------------------- */
   scale *= 0.4f;
   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width( &gui.font, 0, info->author_name );
   mlocal[3][0] *= scale*0.5f;
   mlocal[3][1] = 0.0f;
   mlocal[3][2] = 0.0f;
   m4x3_mul( mtext, mlocal, mmdl );
   font3d_simple_draw( &gui.font, 0, info->author_name, &main_camera, mmdl );
#endif
}

VG_STATIC void skateshop_render_charshop(void)
{
}

VG_STATIC void skateshop_render_worldshop(void)
{
   world_instance *world = world_current_instance();

   ent_skateshop *shop = global_skateshop.ptr_ent;
   ent_marker *mark_display = mdl_arritm( &world->ent_marker,
                                  mdl_entity_id_id(shop->worlds.id_display)),
              *mark_info = mdl_arritm( &world->ent_marker, 
                                  mdl_entity_id_id(shop->boards.id_info));

   /* Text */
   char buftext[128], bufsubtext[128];
   vg_str info, subtext;
   vg_strnull( &info, buftext, 128 );
   vg_strnull( &subtext, bufsubtext, 128 );
   
   if( global_skateshop.world_registry_count ){
      struct registry_world *rw = &global_skateshop.world_registry[
         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, 
                              global_skateshop.world_registry_count, 3 );
      info.buffer[info.i++] = ' ';
      info.buffer[info.i] = '\0';

      vg_strcat( &info, rw->foldername );
      if( skaterift.async_op == k_async_op_world_loading ||
          skaterift.async_op == k_async_op_world_preloading ){
         vg_strcat( &subtext, "Loading..." );
      }
      else{
         vg_strcat( &subtext, "No information" );
      }
   }
   else{
      vg_strcat( &info, "No worlds installed" );
   }


   m4x3f mtext,mlocal,mtextmdl;
   mdl_transform_m4x3( &mark_info->transform, mtext );

   font3d_bind( &gui.font, &main_camera );
   shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );

   float scale = 0.2f, thickness = 0.015f, scale1 = 0.08f;
   m3x3_zero( mlocal );
   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width( &gui.font, 0, buftext );
   mlocal[3][0] *= scale*0.5f;
   mlocal[3][1] = 0.1f;
   mlocal[3][2] = 0.0f;
   m4x3_mul( mtext, mlocal, mtextmdl );
   font3d_simple_draw( &gui.font, 0, buftext, &main_camera, mtextmdl );

   m3x3_setdiagonalv3( mlocal, (v3f){ scale1, scale1, thickness } );
   mlocal[3][0] = -font3d_string_width( &gui.font, 0, bufsubtext );
   mlocal[3][0] *= scale1*0.5f;
   mlocal[3][1] = -scale1*0.3f;
   m4x3_mul( mtext, mlocal, mtextmdl );
   font3d_simple_draw( &gui.font, 0, bufsubtext, &main_camera, mtextmdl );

   /* pointcloud */
   m4x3f mmdl;
   mdl_transform_m4x3( &mark_display->transform, mmdl );
   m4x3_rotate_y( mmdl, vg.time * 0.2 );

   glEnable(GL_BLEND);
   glBlendFunc(GL_ONE, GL_ONE);
   glDisable(GL_DEPTH_TEST);
   pointcloud_render( world, &main_camera, mmdl );
   glDisable(GL_BLEND);
   glEnable(GL_DEPTH_TEST);
}

/*
 * World: render event
 */
VG_STATIC void skateshop_render(void)
{
   if( !global_skateshop.active ) return;
      
   ent_skateshop *shop = global_skateshop.ptr_ent;

   if( shop->type == k_skateshop_type_boardshop ){
      skateshop_render_boardshop();
   }
   else if( shop->type == k_skateshop_type_charshop ){
      skateshop_render_charshop();
   }
   else if( shop->type == k_skateshop_type_worldshop ){
      skateshop_render_worldshop();
   }
   else{
      vg_fatal_error( "Unknown store (%u)\n", shop->type );
   }
}

/*
 * Entity logic: entrance event
 */
VG_STATIC void ent_skateshop_call( world_instance *world, ent_call *call )
{
   u32 index = mdl_entity_id_id( call->id );
   ent_skateshop *shop = mdl_arritm( &world->ent_skateshop, index );
   vg_info( "skateshop_call\n" );

   if( menu.active ) return;
   if( skaterift.async_op != k_async_op_none ) return;

   if( call->function == k_ent_function_trigger ){
      if( localplayer.subsystem != k_player_subsystem_walk ){
         return;
      }
      
      vg_info( "Entering skateshop\n" );

      localplayer.immobile = 1;
      menu.disable_open = 1;
      global_skateshop.active = 1;

      v3_zero( localplayer.rb.v );
      v3_zero( localplayer.rb.w );
      localplayer._walk.move_speed = 0.0f;
      global_skateshop.ptr_ent = shop;
      
      if( shop->type == k_skateshop_type_boardshop ){
         skateshop_update_viewpage();
         workshop_op_item_scan();
      }
      else if( shop->type == k_skateshop_type_worldshop ){
         pointcloud_animate( k_pointcloud_anim_opening );
         skateshop_op_world_scan();
      }
   }
}

/*
 * Entity logic: exit event
 */
VG_STATIC void global_skateshop_exit(void)
{
   vg_info( "exit skateshop\n" );
   localplayer.immobile = 0;
   global_skateshop.active = 0;
   menu.disable_open = 0;
   srinput.ignore_input_frames = 2;
}

#endif /* ENT_SKATESHOP_C */