#include "workshop_types.h"
#include "workshop.h"
-#include "addon_cache.c"
-
static u32 addon_count( enum workshop_file_type type ){
return addon_system.registry_type_counts[ type ];
}
}
VG_STATIC void addon_mount_finish( addon_reg *reg ){
+ addon_print_info( reg );
addon_system.registry_count ++;
}
#include "common.h"
#include "vg/vg_steam_ugc.h"
#include "workshop_types.h"
-#include "addon_cache.h"
+#include "vg/vg_mem_pool.h"
#include "world.h"
#include "player.h"
u32 reg_index;
addon_reg *reg_ptr;
- addon_cache_node cachenode;
+ vg_pool_node cachenode;
}
*boards;
- addon_cache board_cache;
+ vg_pool board_cache;
+
+ struct cache_playermodel{
+ enum cache_board_state state;
+ struct player_model model;
+ u32 reg_index;
+ addon_reg *reg_ptr;
+ vg_pool_node cachenode;
+ }
+ *playermodels;
+ vg_pool playermodel_cache;
SDL_SpinLock sl_cache;
}
+++ /dev/null
-#ifndef ADDON_CACHE_C
-#define ADDON_CACHE_C
-
-#include "addon_cache.h"
-
-static addon_cache_node *addon_cache_nodeptr( addon_cache *cache, void *item ){
- if( !item ) return NULL;
- else return item + cache->offset;
-}
-
-static void *addon_cache_item( addon_cache *cache, u16 index ){
- if( index == ADDON_CACHE_NIL ) return NULL;
- else return cache->buffer + cache->stride*(size_t)index;
-}
-
-static void addon_cache_init( addon_cache *cache ){
- cache->head = 0;
- cache->tail = cache->count -1;
- for( i32 ib=0; ib < cache->count; ib++ ){
- void *vb = addon_cache_item( cache, ib );
- addon_cache_node *nb = addon_cache_nodeptr( cache, vb );
-
- i32 ia = ib-1, ic = ib+1;
- nb->l = ia>=0? ia: ADDON_CACHE_NIL,
- nb->r = ic<cache->count? ic: ADDON_CACHE_NIL;
- nb->ref_count = 0;
- }
-}
-
-static u16 addon_item_index( addon_cache *cache, void *item ){
- return (item - cache->buffer) / cache->stride;
-}
-
-static void *addon_cache_lru( addon_cache *cache ){
- u16 head = cache->head;
- if( head == ADDON_CACHE_NIL ) return NULL;
-
- void *item = addon_cache_item( cache, head );
- addon_cache_node *node = addon_cache_nodeptr( cache, item );
-
- if( cache->head == cache->tail ) cache->tail = ADDON_CACHE_NIL;
- cache->head = node->r;
-
- node->l = ADDON_CACHE_NIL;
- node->r = ADDON_CACHE_NIL;
- return item;
-}
-
-static void addon_cache_watch( addon_cache *cache, void *item ){
- addon_cache_node *node = addon_cache_nodeptr( cache, item );
-
- if( node->ref_count >= 32 )
- vg_fatal_error( "dynamic board watch missmatch (limit is 32)\n" );
-
- node->ref_count ++;
-}
-
-/* if after this no more watches, places back into the volatile list */
-static void addon_cache_unwatch( addon_cache *cache, void *item ){
- addon_cache_node *node = addon_cache_nodeptr( cache, item );
-
- if( node->ref_count == 0 )
- vg_fatal_error( "dynamic board unwatch missmatch (no watchers)\n" );
-
- node->ref_count --;
- if( !node->ref_count ){
- void *item_head = addon_cache_item( cache, cache->head ),
- *item_tail = addon_cache_item( cache, cache->tail );
- addon_cache_node *head = addon_cache_nodeptr( cache, item_head ),
- *tail = addon_cache_nodeptr( cache, item_tail );
-
- u16 index = addon_item_index( cache, item );
- if( tail ) tail->r = index;
- node->l = cache->tail;
- cache->tail = index;
- if( !head ) cache->head = index;
- }
-}
-
-#endif /* ADDON_CACHE_C */
+++ /dev/null
-#ifndef ADDON_CACHE_H
-#define ADDON_CACHE_H
-
-/* cache for loaded addons */
-#define ADDON_CACHE_NIL 0xffff
-
-typedef struct addon_cache addon_cache;
-typedef struct addon_cache_node addon_cache_node;
-
-/* this goes in your structures */
-struct addon_cache_node {
- u16 l, r, ref_count;
-};
-
-struct addon_cache {
- void *buffer; /* array which holds the real data */
- u16 count, head, tail;
- size_t stride, offset;
-};
-
-static addon_cache_node *addon_cache_nodeptr( addon_cache *cache, void *item );
-static void *addon_cache_item( addon_cache *cache, u16 index );
-static void addon_cache_init( addon_cache *cache );
-static u16 addon_item_index( addon_cache *cache, void *item );
-static void *addon_cache_lru( addon_cache *cache );
-static void addon_cache_watch( addon_cache *cache, void *item );
-static void addon_cache_unwatch( addon_cache *cache, void *item );
-
-#endif /* ADDON_CACHE_H */
vg_success( "Written %s (%ub)\n", path, msg->cur );
}
+void write_generic_addon_inf( u32 type, const char *title,
+ const char *content, const char *dest ){
+ u8 descriptor_buf[ 512 ];
+ vg_msg descriptor = {0};
+ descriptor.buf = descriptor_buf;
+ descriptor.max = sizeof(descriptor_buf);
+ vg_msg_frame( &descriptor, "workshop" );
+ vg_msg_wkvstr( &descriptor, "title", title );
+ vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
+ vg_msg_wkvu32( &descriptor, "type", type );
+ vg_msg_end_frame( &descriptor );
+ vg_msg_wkvstr( &descriptor, "content", content );
+ write_msg( &descriptor, dest );
+}
+
void build_shaders(void);
void build_game( enum compiler compiler )
{
vg_build_symbolic_link( "boards_src", "boards" );
vg_build_symbolic_link( "maps_src", "maps" );
vg_build_symbolic_link( "sound_src", "sound" );
+ vg_build_symbolic_link( "playermodels_src", "playermodels" );
vg_build_syscall( "mkdir -p %s/cfg", vg_compiler.build_dir );
- u8 descriptor_buf[ 512 ];
-
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Longboard" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board );
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_long/addon.inf" );
- }
-
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Fractal" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board );
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_fract/addon.inf" );
- }
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Striped" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board );
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_striped/addon.inf" );
- }
-
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Licco" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board);
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_licco/addon.inf" );
- }
-
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Hypno" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board );
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_spiral/addon.inf" );
- }
-
- {
- vg_msg descriptor = {0};
- descriptor.buf = descriptor_buf;
- descriptor.max = sizeof(descriptor_buf);
- vg_msg_frame( &descriptor, "workshop" );
- vg_msg_wkvstr( &descriptor, "title", "Shark" );
- vg_msg_wkvstr( &descriptor, "author", "Skaterift" );
- vg_msg_wkvu32( &descriptor, "type", k_workshop_file_type_board );
- vg_msg_end_frame( &descriptor );
- vg_msg_wkvstr( &descriptor, "content", "board.mdl" );
- write_msg( &descriptor, "boards_src/skaterift_shark/addon.inf" );
- }
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Longboard", "board.mdl",
+ "boards_src/skaterift_long/addon.inf");
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Fractal", "board.mdl",
+ "boards_src/skaterift_fract/addon.inf");
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Striped", "board.mdl",
+ "boards_src/skaterift_striped/addon.inf");
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Licco", "board.mdl",
+ "boards_src/skaterift_licco/addon.inf");
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Hypno", "board.mdl",
+ "boards_src/skaterift_spiral/addon.inf");
+ write_generic_addon_inf( k_workshop_file_type_board,
+ "Shark", "board.mdl",
+ "boards_src/skaterift_shark/addon.inf");
+
+ write_generic_addon_inf( k_workshop_file_type_player,
+ "De'folde", "ch_new.mdl",
+ "playermodels_src/skaterift_new/addon.inf" );
+ write_generic_addon_inf( k_workshop_file_type_player,
+ "Jordan", "ch_jordan.mdl",
+ "playermodels_src/skaterift_jordan/addon.inf" );
+ write_generic_addon_inf( k_workshop_file_type_player,
+ "Outlaw", "ch_outlaw.mdl",
+ "playermodels_src/skaterift_outlaw/addon.inf" );
vg_build();
compiled_something = 1;
SDL_AtomicLock( &addon_system.sl_cache );
struct cache_board *min_board =
- addon_cache_lru( &addon_system.board_cache );
+ vg_pool_lru( &addon_system.board_cache );
if( min_board ){
if( min_board->state == k_cache_board_state_loaded ){
struct shop_view_slot *slot = &global_skateshop.shop_view_slots[i];
u32 request_id = page*SKATESHOP_VIEW_SLOT_MAX + i;
- addon_cache *cache = &addon_system.board_cache;
+ vg_pool *cache = &addon_system.board_cache;
if( slot->cache_ptr )
- addon_cache_unwatch( cache, slot->cache_ptr );
+ vg_pool_unwatch( cache, slot->cache_ptr );
slot->cache_ptr = skateshop_cache_fetch_board( request_id );
if( slot->cache_ptr )
- addon_cache_watch( cache, slot->cache_ptr );
+ vg_pool_watch( cache, slot->cache_ptr );
}
}
board->reg_index = 0xffffffff;
}
- addon_cache *cache = &addon_system.board_cache;
+ vg_pool *cache = &addon_system.board_cache;
cache->buffer = addon_system.boards;
cache->count = CACHE_BOARD_MAX;
cache->stride = sizeof( struct cache_board );
cache->offset = offsetof( struct cache_board, cachenode );
- addon_cache_init( cache );
+ vg_pool_init( cache );
}
VG_STATIC struct cache_board *skateshop_selected_cache_if_loaded(void)
global_skateshop.selected_board_id );
if( localplayer.board_view_slot ){
- addon_cache_unwatch( &addon_system.board_cache,
+ vg_pool_unwatch( &addon_system.board_cache,
localplayer.board_view_slot );
}
localplayer.board_view_slot = selected_cache;
- addon_cache_watch( &addon_system.board_cache,
+ vg_pool_watch( &addon_system.board_cache,
localplayer.board_view_slot );
global_skateshop_exit();
skaterift_write_savedata();
/*
- * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
*/
#ifndef MODEL_H
#define MODEL_H
-#include "common.h"
+#include "skaterift.h"
#define MDL_VERSION_NR 101
typedef struct mdl_array mdl_array;
typedef struct mdl_header mdl_header;
+typedef struct glmesh glmesh;
+struct glmesh
+{
+ GLuint vao, vbo, ebo;
+ u32 indice_count;
+ u32 loaded;
+};
+
struct mdl_transform
{
v3f co, s;
mdl_array index;
};
-struct mdl_context
-{
+struct mdl_context{
FILE *file;
mdl_header info;
- struct mdl_array_ptr
- {
+ struct mdl_array_ptr{
void *data;
u32 count, stride;
}
/* mesh buffers */
verts,
indices;
-
u32 pack_base_offset;
-
- /* pack data */
- //pack;
+
+ /* runtime */
+ glmesh mesh;
};
* ----------------------------------------------------------------------------
*/
-typedef struct glmesh glmesh;
-struct glmesh
-{
- GLuint vao, vbo, ebo;
- u32 indice_count;
- u32 loaded;
-};
-
VG_STATIC void mesh_upload( glmesh *mesh,
mdl_vert *verts, u32 vert_count,
u32 *indices, u32 indice_count )
VG_STATIC void async_mdl_load_glmesh( void *payload, u32 size )
{
struct payload_glmesh_load *job = payload;
-
mesh_upload( job->mesh, job->verts, job->vertex_count,
job->indices, job->indice_count );
}
+/* TODO: Find out if this needs deprecating in favour of the new full loader */
VG_STATIC void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh )
{
mdl_array *arr_vertices = mdl_find_array( mdl, "mdl_vert" );
vg_fatal_error( "no vertex/indice data\n" );
}
}
+
+/* uploads the glmesh, and textures. everything is saved into the mdl_context */
+VG_STATIC void mdl_async_full_load_std( mdl_context *mdl ){
+ mdl_async_load_glmesh( mdl, &mdl->mesh );
+
+ for( u32 i=0; i<mdl_arrcount( &mdl->textures ); i ++ ){
+ vg_linear_clear( vg_mem.scratch );
+ mdl_texture *tex = mdl_arritm( &mdl->textures, i );
+
+ void *data = vg_linear_alloc( vg_mem.scratch, tex->file.pack_size );
+ mdl_fread_pack_file( mdl, &tex->file, data );
+
+ vg_tex2d_load_qoi_async( data, tex->file.pack_size,
+ VG_TEX2D_CLAMP|VG_TEX2D_NEAREST, &tex->glname );
+ }
+}
#endif
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;
}
+#endif
PLAYER_API
void player__bind( player_instance *player )
*/
struct player_avatar *playeravatar;
- struct player_model *playermodel;
struct player_ragdoll ragdoll;
+ //struct player_model *playermodel;
//struct player_board *board;
- struct cache_board *board_view_slot;
+ struct cache_board *board_view_slot;
+ struct cache_playermodel *playermodel_view_slot;
player_pose holdout_pose;
float holdout_time;
angles[1] = vg_clampf( angles[1], -VG_PIf*0.5f, VG_PIf*0.5f );
}
-struct player_board *player_get_player_board( struct player_instance *player )
-{
- struct player_board *board = NULL;
-
+struct player_board *player_get_player_board( struct player_instance *player ){
if( localplayer.board_view_slot ){
struct cache_board *cache_view = localplayer.board_view_slot;
if( cache_view->state == k_cache_board_state_loaded ){
- board = &cache_view->board;
+ return &cache_view->board;
+ }
+ }
+
+ return NULL;
+}
+
+struct player_model *player_get_player_model( struct player_instance *player ){
+ if( localplayer.playermodel_view_slot ){
+ struct cache_playermodel *cache_view = localplayer.playermodel_view_slot;
+ if( cache_view->state == k_cache_board_state_loaded ){
+ return &cache_view->model;
}
}
- return board;
+ return NULL;
}
#endif /* PLAYER_COMMON_C */
}
/* TODO: allow error handling */
-VG_STATIC void player_board_load( struct player_board *mdl, const char *path )
-{
+VG_STATIC void player_board_load( struct player_board *mdl, const char *path ){
vg_linear_clear( vg_mem.scratch );
mdl_context ctx;
mdl_async_load_glmesh( &ctx, &mdl->mesh );
mdl_close( &ctx );
+ /* TODO: you get put into a new section, the above is standard mdl loads. */
for( int i=0; i<4; i++ )
mdl->wheels[i].indice_count = 0;
for( int i=0; i<2; i++ )
shader_model_board_view_uCamera( cam->transform[3] );
shader_model_board_view_uPv( cam->mtx.pv );
shader_model_board_view_uTexSceneDepth( 1 );
+ render_fb_bind_texture( gpipeline.fb_main, 2, 1 );
render_fb_inverse_ratio( gpipeline.fb_main, inverse );
}
}
-PLAYER_API void player__render( camera *cam, player_instance *player )
-{
+VG_STATIC void render_playermodel( camera *cam, world_instance *world,
+ struct player_model *model,
+ struct skeleton *skeleton ){
+ if( !model ) return;
+
shader_model_character_view_use();
glActiveTexture( GL_TEXTURE0 );
- glBindTexture( GL_TEXTURE_2D, player->playermodel->texture );
+ glBindTexture( GL_TEXTURE_2D, model->texture );
shader_model_character_view_uTexMain( 0 );
shader_model_character_view_uCamera( cam->transform[3] );
shader_model_character_view_uPv( cam->mtx.pv );
inverse[2] = cam->farz-cam->nearz;
shader_model_character_view_uInverseRatioMain( inverse );
- world_instance *world = world_current_instance();
world_link_lighting_ub( world, _shader_model_character_view.id );
world_bind_position_texture( world, _shader_model_character_view.id,
_uniform_model_character_view_g_world_depth, 2 );
_uniform_model_character_view_uLightsIndex, 4 );
glUniformMatrix4x3fv( _uniform_model_character_view_uTransforms,
- player->playeravatar->sk.bone_count,
+ skeleton->bone_count,
0,
- (float *)player->playeravatar->sk.final_mtx );
+ (float *)skeleton->final_mtx );
- mesh_bind( &player->playermodel->mesh );
- mesh_draw( &player->playermodel->mesh );
+ mesh_bind( &model->mesh );
+ mesh_draw( &model->mesh );
+}
- struct player_board *board = player_get_player_board( player );
+PLAYER_API void player__render( camera *cam, player_instance *player )
+{
+ world_instance *world = world_current_instance();
+
+ struct player_model *model = player_get_player_model( player );
+ render_playermodel( cam, world, model, &player->playeravatar->sk );
+ struct player_board *board = player_get_player_board( player );
render_board( cam, world, board, player->playeravatar->sk.final_mtx[
player->playeravatar->id_board],
k_board_shader_player );
id_board;
};
-struct player_model
-{
- glmesh mesh;
- GLuint texture;
-};
-
enum eboard_truck{
k_board_truck_back = 0,
k_board_truck_front = 1
k_board_wheel_br = 3,
};
-struct player_board
-{
+struct player_board{
+ mdl_context model;
+
glmesh mesh;
GLuint texture;
board;
};
+struct player_model{
+ glmesh mesh;
+ GLuint texture;
+};
+
enum board_shader{
k_board_shader_player,
k_board_shader_entity
#include "save.c"
static struct player_avatar localplayer_avatar;
+
+#if 0
static struct player_model localplayer_models[3];
+#endif
int main( int argc, char *argv[] )
{
VG_STATIC void load_playermodels(void)
{
+#if 0
player_model_load( &localplayer_models[0], "models/ch_new.mdl" );
player_model_load( &localplayer_models[1], "models/ch_outlaw.mdl" );
player_model_load( &localplayer_models[2], "models/ch_jordan.mdl" );
+#endif
/* FIXME: hack */
shader_model_character_view_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 )
player__create( &localplayer );
player_avatar_load( &localplayer_avatar, "models/ch_new.mdl" );
player__use_avatar( &localplayer, &localplayer_avatar );
+#if 0
player__use_model( &localplayer, &localplayer_models[k_playermdl_id] );
+#endif
player__bind( &localplayer );
/* --------------------- */
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,
+ "playermodels", ".mdl" );
addon_mount_content_folder( k_workshop_file_type_board, "boards", ".mdl" );
addon_mount_workshop_items();
vg_async_call( async_addon_reg_update, NULL, 0 );
query_workshop_id, query_local_folder );
if( reg_id != 0xffffffff ){
localplayer.board_view_slot = skateshop_cache_fetch_board( reg_id );
- addon_cache_watch( &addon_system.board_cache,
- localplayer.board_view_slot );
+ vg_pool_watch( &addon_system.board_cache, localplayer.board_view_slot );
}
board_processview_thread(NULL); /* END_OP!! */
#include "common.h"
#include "world.h"
#include "addon.h"
-#include "addon_cache.h"
struct{
enum async_operation{
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff