[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"
#include "addon.h"
#include "save.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;
}

#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 );
   }
   
   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;
   }
}

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

/*
 * 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_workshop_items();
   vg_async_call( async_addon_reg_update, NULL, 0 );
   skaterift_end_op();
}

/*
 * 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 );
}

VG_STATIC void board_processview_thread( void *_args ){
   workshop_visibile_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_workshop_items();
   vg_async_call( async_addon_reg_update, NULL, 0 );
   vg_async_stall();
   board_processview_thread(NULL);
}

VG_STATIC void skateshop_op_board_scan(void){
   skaterift_begin_op( k_async_op_board_scan );
   vg_loader_start( board_scan_thread, NULL );
}

VG_STATIC void skateshop_op_processview(void){
   skaterift_begin_op( k_async_op_board_scan );
   vg_loader_start( board_processview_thread, NULL );
}

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

/*
 * VG event init
 */
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,
                                            global_skateshop.selected_board_id);
      return reg->cache_id;
   }
   else return 0;
}

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

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

VG_STATIC void skateshop_preview_loader_thread( void *_data )
{
   addon_reg *reg = _data;

   char path_buf[4096];
   vg_str path;
   vg_strnull( &path, path_buf, 4096 );
   addon_get_content_folder( reg, &path );
   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 );
   }
}

VG_STATIC void skateshop_preview_loader_thread_and_end( void *_data ){
   skateshop_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 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 ){
      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" );

      u16 cache_id = skateshop_selected_cache_id();
      if( cache_id ){
         gui_helper_action( button_display_string( k_srbind_maccept ), "pick" );
      }

      /*
       * Controls
       * ----------------------
       */
      u32 opage = global_skateshop.selected_board_id/SKATESHOP_VIEW_SLOT_MAX;

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

      if( button_down( k_srbind_mright ) ){
         if( global_skateshop.selected_board_id+1 < 
               addon_count(k_workshop_file_type_board) )
         {
            global_skateshop.selected_board_id ++;
         }
      }

      u32 npage = global_skateshop.selected_board_id/SKATESHOP_VIEW_SLOT_MAX;

      if( opage != npage ){
         skateshop_update_viewpage();
         skateshop_op_processview();
      }
      else if( cache_id && button_down( k_srbind_maccept )){
         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 );
         }

         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 ){
      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( k_playermdl_id > 0 ){
            k_playermdl_id --;
         }
         else{
            k_playermdl_id = 2; /* HACK */
         }
         temp_update_playermodel(); /* HACK */
      }

      if( button_down( k_srbind_mright ) ){
         if( k_playermdl_id+1 < 3 ){
            k_playermdl_id ++;
         }
         else{
            k_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( addon_count(k_workshop_file_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" );
         browseable = 1;
      }

      if( (skaterift.async_op == k_async_op_none) &&
           global_skateshop.selected_world_id > 0 ){
         gui_helper_action( button_display_string(k_srbind_maccept), 
                            "open rift" );
         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 < 
                     addon_count(k_workshop_file_type_world) )
            {
               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 ){
         addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
            global_skateshop.selected_world_id );

         /* automatically load in clouds */
         if( loadable && button_down( k_srbind_maccept ) ){
            vg_info( "Select rift (%u)\n", 
                      global_skateshop.selected_world_id );
            world_loader.reg = reg;
            world_loader.override_name[0] = '\0';
            skaterift_change_world_start();
            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( reg );
               }
               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));

   SDL_AtomicLock( &addon_system.sl_cache_using_resources );
   struct addon_cache *cache = &addon_system.cache[k_workshop_file_type_board];
   
   /* 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( !slot->cache_id ) 
         goto fade_out;

      addon_cache_entry *entry = vg_pool_item( &cache->pool, slot->cache_id );

      if( entry->state != k_addon_cache_state_loaded )
         goto fade_out;

      struct player_board *board = 
         addon_cache_item( k_workshop_file_type_board, slot->cache_id );

      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( entry->reg_index == global_skateshop.selected_board_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, 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( addon_count(k_workshop_file_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 );
      buf[i++] = '\0';

      font3d_simple_draw( &gui.font, 0, buf, &main_camera, mmdl );
   }
   else{
      font3d_simple_draw( &gui.font, 0, 
                          "Nothing installed", &main_camera, mmdl );
   }

   u16 cache_id = skateshop_selected_cache_id();
   struct addon_cache_entry *entry = vg_pool_item( &cache->pool, cache_id );
   addon_reg *reg = NULL;

   if( entry ) reg = entry->reg_ptr;

   if( !reg ){
      SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
      global_skateshop.render.item_title = "";
      global_skateshop.render.item_desc = "";
      return;
   }

   if( global_skateshop.render.reg_id != global_skateshop.selected_board_id ){
      global_skateshop.render.item_title = "";
      global_skateshop.render.item_desc = "";
      vg_msg root = {0};
      root.buf = reg->metadata;
      root.len = reg->metadata_len;
      root.max = sizeof(reg->metadata);

      vg_msg workshop = root;
      if( vg_msg_seekframe( &workshop, "workshop", 0 ) ){
         const char *title = vg_msg_seekkvstr( &workshop, "title", 0 );
         if( title ) global_skateshop.render.item_title = title;

         const char *dsc = vg_msg_seekkvstr( &workshop, "author", 0 );
         if( dsc ) global_skateshop.render.item_desc = dsc;
      }

      global_skateshop.render.reg_id = global_skateshop.selected_board_id;
   }

   /* Skin title
    * ----------------------------------------------------------------- */
   m3x3_zero( mlocal );
   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width( &gui.font, 0, 
                                        global_skateshop.render.item_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, global_skateshop.render.item_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, 
                                        global_skateshop.render.item_desc );
   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, global_skateshop.render.item_desc, 
                       &main_camera, mmdl );

   SDL_AtomicUnlock( &addon_system.sl_cache_using_resources );
}

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));

   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,
                                       global_skateshop.selected_world_id );
      vg_msg root = {0};
      root.buf = reg->metadata;
      root.len = reg->metadata_len;
      root.max = sizeof(reg->metadata);
      vg_msg workshop = root;
      if( vg_msg_seekframe( &workshop, "workshop", 0 ) ){
         global_skateshop.render.world_title = vg_msg_seekkvstr( &workshop, 
                                                                 "title", 0 );
      }
      global_skateshop.render.world_loc = vg_msg_seekkvstr(&root,"location",0);
      global_skateshop.render.world_reg = global_skateshop.selected_world_id;
   }

   /* Text */
   char buftext[128], bufsubtext[128];
   vg_str info, subtext;
   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,
                           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 );
      info.buffer[info.i++] = ' ';
      info.buffer[info.i] = '\0';

      vg_strcat( &info, global_skateshop.render.world_title );
      if( skaterift.async_op == k_async_op_world_loading ||
          skaterift.async_op == k_async_op_world_preloading ){
         vg_strcat( &subtext, "Loading..." );
      }
      else{
         addon_reg *reg = get_addon_from_index( k_workshop_file_type_world,
                                          global_skateshop.selected_world_id );

         if( reg->workshop_id )
            vg_strcat( &subtext, "(Workshop) " );

         vg_strcat( &subtext, global_skateshop.render.world_loc );
      }
   }
   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();
         skateshop_op_board_scan();
      }
      else if( shop->type == k_skateshop_type_charshop ){
         
      }
      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 */