my fucking fingers

[carveJwlIkooP6JGAAIwe30JlM.git] / ent_skateshop.c

#ifndef ENT_SKATESHOP_C
#define ENT_SKATESHOP_C

#include "ent_skateshop.h"
#include "world.h"
#include "player.h"
#include "gui.h"

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

static int skateshop_workshop_name_blacklisted( u32 hash, const char *name )
{
   if( const_str_eq( hash, name, "skaterift_fish.mdl" ) ) return 1;
   return 0;
}

VG_STATIC void skateshop_loader_start( void (*pfn)(void *data) )
{
   if( global_skateshop.loading )
      vg_fatal_error( "skateshop thread sync failure\n" );

   global_skateshop.loading = 1;
   vg_loader_start( pfn, NULL );
}

VG_STATIC void skateshop_async_post( void *payload, u32 size )
{
   global_skateshop.loading = 0;
}

VG_STATIC 
struct dynamic_board *skateshop_lru_alloc( u32 id )
{
   double min_time = 1e300;
   struct dynamic_board *min_board = NULL;

   for( u32 i=0; i<MAX_DYNAMIC_BOARDS; i++ ){
      struct dynamic_board *db = &global_skateshop.dynamic_boards[i];

      if( db->state == k_dynamic_board_state_loading )
         continue;

      if( db->ref_count )
         continue;

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

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

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

         player_board_unload( &min_board->board );
         other->dynamic = NULL;
      }

      struct board_registry *reg = &global_skateshop.registry[id];

      vg_info( "Allocating board '%s' @%p\n", reg->filename, min_board );

      min_board->state = k_dynamic_board_state_loading;
      min_board->registry_id = id;
      min_board->last_use_time = vg.time;
      min_board->ref_count = 0;
   }
   else{
      vg_error( "No free boards to load registry!\n" );
   }

   return min_board;
}

VG_STATIC 
void skateshop_board_registry_path( struct board_registry *reg, char path[256] )
{
   if( reg->workshop ){
      snprintf( path, 256, "models/boards/workshop/%s/something.mdl", 
                reg->filename );
   }
   else{
      snprintf( path, 256, "models/boards/%s", reg->filename );
   }
}

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

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

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

   db->ref_count --;
}

VG_STATIC void skateshop_async_board_complete( void *payload, u32 size )
{
   struct dynamic_board *db = payload;

   /* all possible view slots are 'listening' for this event, 
    * which must be checked here */
   for( u32 i=0; i<vg_list_size(global_skateshop.shop_view_slots); i++ ){
      if( global_skateshop.shop_view_slots[i].db == db ){
         watch_dynamic_board( db );
      }
   }

   if( localplayer.board_view_slot == db ){
      watch_dynamic_board( db );
   }

   db->last_use_time = vg.time;
   db->state = k_dynamic_board_state_loaded;

   struct board_registry *reg = &global_skateshop.registry[ db->registry_id ];
   reg->dynamic = db;

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

VG_STATIC void skateshop_load_requested_boards(void)
{
   char path[256];
   for( u32 i=0; i<MAX_DYNAMIC_BOARDS; i++ ){
      struct dynamic_board *db = &global_skateshop.dynamic_boards[i];
   
      if( db->state == k_dynamic_board_state_loading ){
         struct board_registry *reg = 
            &global_skateshop.registry[ db->registry_id ];

         skateshop_board_registry_path( reg, path );
         player_board_load( &db->board, path );
         vg_async_call( skateshop_async_board_complete, db, 0 );
      }
   }
}

VG_STATIC void skateshop_thread1_refresh( void *data )
{
   skateshop_load_requested_boards();
   vg_async_call( skateshop_async_post, NULL, 0 );
}

VG_STATIC int skateshop_use_board( int argc, const char *argv[] )
{
   if( global_skateshop.loading ){
      vg_error( "Cannot use skateshop currently (loader thread missing)\n" );
      return 0;
   }

   if( argc == 1 ){
      u32 hash = vg_strdjb2( argv[0] );

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

         if( const_str_eq( hash, argv[0], reg->filename ) ){
            if( reg->dynamic ){
               struct dynamic_board *db = reg->dynamic;

               if( db->state == k_dynamic_board_state_loaded ){
                  localplayer.board_view_slot = db;
                  watch_dynamic_board( db );
               }
               else{
                  vg_fatal_error( "Invalid state while loading board\n" );
               }
            }
            else{
               if( localplayer.board_view_slot ){
                  unwatch_dynamic_board( localplayer.board_view_slot );
                  localplayer.board_view_slot = NULL;
               }

               struct dynamic_board *db = skateshop_lru_alloc( i );
               localplayer.board_view_slot = db;
               db->state = k_dynamic_board_state_loading;
               skateshop_loader_start( skateshop_thread1_refresh );
            }
            return 1;
         }
      }
   }
   return 0;
}

VG_STATIC void skateshop_use_board_suggest( int argc, const char *argv[] )
{
   if( argc == 1 ){
      for( u32 i=0; i<global_skateshop.registry_count; i++ ){
         struct board_registry *reg = &global_skateshop.registry[i];

         if( reg->ghost ) continue; /* we probably can't load these */

         console_suggest_score_text( reg->filename, argv[0], 0 );
      }
   }
}

VG_STATIC void skateshop_scan_for_items( void *data )
{
   vg_linear_clear( vg_mem.scratch );

   for( u32 i=0; i<global_skateshop.registry_count; i++ ){
      struct board_registry *reg = &global_skateshop.registry[i];
      reg->ghost = 1;
   }

   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.registry_count; i++ ){
            struct board_registry *reg = &global_skateshop.registry[i];

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

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

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

         struct board_registry *reg = &global_skateshop.registry[
                                          global_skateshop.registry_count ++ ];

         reg->dynamic = NULL;
         vg_strncpy( file.name, reg->filename, 64, k_strncpy_always_add_null );
         reg->filename_hash = hash;
         reg->uid = 0;
         reg->workshop = 0;
         reg->ghost = 0;
      }

next_file: tinydir_next( &dir );
   }

   tinydir_close(&dir);

   skateshop_load_requested_boards();
   vg_async_call( skateshop_async_post, NULL, 0 );
}

VG_STATIC void global_skateshop_exit(void)
{
   vg_info( "exit skateshop\n" );
   localplayer.immobile = 0;
   global_skateshop.active = 0;
   srinput.ignore_input_frames = 2;
}

VG_STATIC void skateshop_request_viewpage( u32 page )
{
   u32 slot_count = vg_list_size(global_skateshop.shop_view_slots);
   u32 start = page * slot_count;

   for( u32 i=0; i<slot_count; i++ ){
      struct shop_view_slot *slot = &global_skateshop.shop_view_slots[i];
      
      if( slot->db ){
         slot->db->ref_count --;
         slot->db = NULL;
      }

      u32 reg_index = start+i;
      if( reg_index < global_skateshop.registry_count ){
         struct board_registry *reg = &global_skateshop.registry[ reg_index ];

         if( reg->dynamic ){
            struct dynamic_board *db = reg->dynamic;

            if( db->state == k_dynamic_board_state_loaded ){
               db->last_use_time = vg.time;
               db->ref_count ++;
               slot->db = db;
            }
            else{
               vg_fatal_error( "Invalid state while loading page\n" );
            }
         }
         else{
            struct dynamic_board *db = skateshop_lru_alloc( reg_index );

            if( db ){
               db->ref_count ++;
               slot->db = db;
            }
         }
      }
   }
}

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( global_skateshop.loading ){
      vg_error( "Cannot enter skateshop currently (loader thread missing)\n" );
      return;
   }

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

      localplayer.immobile = 1;
      global_skateshop.active = 1;
      global_skateshop.interface_loc = k_skateshop_loc_page__viewing;

      v3_zero( localplayer.rb.v );
      v3_zero( localplayer.rb.w );
      localplayer._walk.move_speed = 0.0f;

      global_skateshop.ptr_ent = shop;

      skateshop_request_viewpage(0);
      skateshop_loader_start( skateshop_scan_for_items );
   }
}

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 = get_active_world();

   ent_skateshop *shop = global_skateshop.ptr_ent;
   ent_camera *ref = mdl_arritm( &world->ent_camera, 
                                 mdl_entity_id_id(shop->id_camera) );
   ent_marker *display = mdl_arritm( &world->ent_marker,
                                 mdl_entity_id_id(shop->id_display) );
   
   v3f dir = {0.0f,-1.0f,0.0f};
   mdl_transform_vector( &ref->transform, dir, dir );
   player_vector_angles( localplayer.cam_override_angles, dir, 1.0f, 0.0f );
   
   v3f lookat;
   v3_sub( display->transform.co, localplayer.rb.co, lookat );
   
   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;

   if( global_skateshop.interaction_cooldown > 0.0f ){
      global_skateshop.interaction_cooldown -= vg.time_delta;
      return;
   }

   if( global_skateshop.interface_loc <= k_skateshop_loc_page__viewing ){

      gui_helper_action( axis_display_string( k_sraxis_mbrowse_h ), "browse" );
      gui_helper_action( button_display_string( k_srbind_mback ), "exit" );

      u32 reg_id = global_skateshop.selected_registry_id;
      struct board_registry *picker = &global_skateshop.registry[ reg_id ];

      int pick_availible = 0;
      if( picker->dynamic && 
            (picker->dynamic->state == k_dynamic_board_state_loaded ) )
      {
         pick_availible = 1;
         gui_helper_action( button_display_string( k_srbind_maccept ), "pick" );
      }
      
      int moved = 0;

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

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

      if( moved ){
         vg_info( "Select registry: %u\n", 
                  global_skateshop.selected_registry_id );
         global_skateshop.interaction_cooldown = 0.125f;
         return;
      }

      if( pick_availible && button_down( k_srbind_maccept ) ){
         vg_info( "chose board from skateshop (%u)\n", reg_id );

         if( localplayer.board_view_slot ){
            unwatch_dynamic_board( localplayer.board_view_slot );
            localplayer.board_view_slot = NULL;
         }

         localplayer.board_view_slot = picker->dynamic;
         watch_dynamic_board( localplayer.board_view_slot );

         global_skateshop_exit();
         return;
      }

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

VG_STATIC void skateshop_init(void)
{
   global_skateshop.registry =
      vg_linear_alloc( vg_mem.rtmemory, 
                       sizeof(struct board_registry)*MAX_LOCAL_BOARDS );
   global_skateshop.registry_count = 0;
   global_skateshop.dynamic_boards =
      vg_linear_alloc( vg_mem.rtmemory, 
                       sizeof(struct dynamic_board)*MAX_DYNAMIC_BOARDS );

   memset( global_skateshop.dynamic_boards, 0,
            sizeof(struct dynamic_board)*MAX_DYNAMIC_BOARDS );

   for( u32 i=0; i<MAX_DYNAMIC_BOARDS; i++ ){
      struct dynamic_board *board = &global_skateshop.dynamic_boards[i];
      board->state = k_dynamic_board_state_none;
      board->registry_id = 0xffffffff;
      board->last_use_time = -99999.9;
      board->ref_count = 0;
   }

   vg_console_reg_cmd( "use_board", 
                       skateshop_use_board, skateshop_use_board_suggest );

   //skateshop_scan_for_items(NULL);
}

VG_STATIC void skateshop_render(void)
{
   if( !global_skateshop.active ) return;
      
   ent_skateshop *shop = global_skateshop.ptr_ent;
   world_instance *world = get_active_world();

   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->id_rack)),
              *mark_display = mdl_arritm( &world->ent_marker,
                                  mdl_entity_id_id(shop->id_display));
   
   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->db ) 
         goto set_fade_amt;

      if( slot->db->state != k_dynamic_board_state_loaded ) 
         goto set_fade_amt;

      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->db->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->db->board, mmdl,
                    k_board_shader_entity );

set_fade_amt:;
      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->id_info));
   m4x3f mtext, mrack;
   mdl_transform_m4x3( &mark_info->transform, mtext );
   mdl_transform_m4x3( &mark_rack->transform, mrack );

   const char *text_title = "Fish - Title";
   const char *text_author = "by Shaniqua";

   m4x3f mlocal, mmdl;
   m4x3_identity( mlocal );

   /* Skin title
    * ----------------------------------------------------------------- */
   float scale = 0.2f,
         thickness = 0.03f;

   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width(&world_global.font,0,text_title);
   mlocal[3][0] *= scale*0.5f;
   mlocal[3][1] = 0.1f;
   m4x3_mul( mtext, mlocal, mmdl );

   font3d_bind( &world_global.font, &main_camera );

   shader_model_font_uColour( (v4f){1.0f,1.0f,1.0f,1.0f} );
   font3d_simple_draw( &world_global.font, 0, text_title, &main_camera, mmdl );

   /* Author name
    * ----------------------------------------------------------------- */
   scale *= 0.4f;
   m3x3_setdiagonalv3( mlocal, (v3f){ scale, scale, thickness } );
   mlocal[3][0] = -font3d_string_width(&world_global.font,0,text_author);
   mlocal[3][0] *= scale*0.5f;
   mlocal[3][1] = 0.0f;
   m4x3_mul( mtext, mlocal, mmdl );
   font3d_simple_draw( &world_global.font, 0, text_author, &main_camera, mmdl );

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

   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( &world_global.font, 0, buf, &main_camera, mmdl );
}

#endif /* ENT_SKATESHOP_C */