#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;
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;
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;
}
}
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;
{
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;
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];
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" );
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;
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;
}
* 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];
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;
}
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;
}
* 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 )
{
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 );
}
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 ) ){
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 );
}
}
-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];
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 */
#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"
/* 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{
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{
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 */
--- /dev/null
+#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 */
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 = []
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 ]
#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
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" );
+++ /dev/null
-#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 */
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 );
}
}
* -----------------------------------------------------------------------------
*/
-/*
- * 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();
}
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();
}
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;
}
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;
}
}
-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 );
}
/*
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 ++;
}
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 ) ){
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" );
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;
}
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 */
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++ ){
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 );
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 );
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;
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';
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 );
u32 selected_world_id,
selected_board_id,
+ selected_player_id,
pointcloud_world_id;
struct {
#include "vg/vg_console.h"
#include "vg/vg_input.h"
#include "vg/vg_m.h"
-#include "conf.h"
#include "font.h"
enum sr_bind{
#include "model.h"
#include "world_render.h"
#include "player.h"
-#include "conf.h"
#include "shaders/model_menu.h"
#include "audio.h"
#include "input.h"
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 )
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;
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 );
#include "ent_skateshop.h"
#include "player.h"
-#include "conf.h"
#include "input.h"
#include "menu.h"
#include "vg/vg_perlin.h"
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 ){
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 );
}
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;
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],
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 */
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 ){
}
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;
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;
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;
"{\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"
{
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 );
"{\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"
* --------------------- */
#include "skaterift.h"
-#include "conf.h"
#include "steam.h"
#include "render.h"
#include "audio.h"
VG_STATIC void vg_preload(void)
{
- conf_init();
skaterift_read_savedata();
vg_info(" Copyright . . . -----, ,----- ,---. .---. \n" );
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();
/* 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 );
/* --------------------- */
/* 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};
/* 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};
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();
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!! */
}
#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"
};
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 },
};
/*
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;
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 );
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 );
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/" );
*/
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;
}
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);
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;
}
}
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;
}
}
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;
}
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 );
}
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
};
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 );
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, "???." );
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();
}
#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"
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 */
+++ /dev/null
-#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 */
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 );
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 );
}
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff