u32 reg_size = sizeof(addon_reg)*ADDON_MOUNTED_MAX;
addon_system.registry = vg_linear_alloc( vg_mem.rtmemory, reg_size );
- for( u32 type=0; type<k_addon_type_max; type++ ){
+ 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->cache_count ){
+ if( inf->cache_count )
+ {
/* create the allocations pool */
u32 alloc_size = sizeof(struct addon_cache_entry)*inf->cache_count;
cache->allocs = vg_linear_alloc( vg_mem.rtmemory, alloc_size );
cache->stride = inf->cache_stride;
memset( cache->items, 0, cache_size );
- for( i32 j=0; j<inf->cache_count; j++ ){
+ if( inf->item_arena_size )
+ {
+ u32 index_size = inf->cache_count * sizeof( void* );
+ cache->arenas = vg_linear_alloc( vg_mem.rtmemory, index_size );
+ }
+
+ 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;
+
+ if( inf->item_arena_size )
+ {
+ cache->arenas[j] = _vg_create_linear_allocator(
+ vg_mem.rtmemory, inf->item_arena_size, VG_MEMORY_SYSTEM,
+ "Item cache's arena" );
+ }
}
}
}
return cache->items + ((size_t)(id-1) * cache->stride);
}
+void *addon_cache_item_arena( enum addon_type type, u16 id )
+{
+ VG_ASSERT( id );
+ struct addon_cache *cache = &addon_system.cache[type];
+ return cache->arenas[ id-1 ];
+}
+
/*
* Get the real item data for cache id ONLY if the item is completely loaded.
*/
return 0;
}
- if( type == k_addon_type_board ){
+ if( type == k_addon_type_board )
+ {
struct player_board *board = addon_cache_item( type, id );
- player_board_load( board, content_path.buffer );
+ void *arena = addon_cache_item_arena( type, id );
+ vg_linear_clear( arena );
+
+ player_board_load( board, content_path.buffer, arena );
return 1;
}
- else if( type == k_addon_type_player ){
+ else if( type == k_addon_type_player )
+ {
struct player_model *model = addon_cache_item( type, id );
- player_model_load( model, content_path.buffer );
+ void *arena = addon_cache_item_arena( type, id );
+ vg_linear_clear( arena );
+
+ player_model_load( model, content_path.buffer, arena );
return 1;
}
else {
*allocs;
vg_pool pool;
+ void **arenas;
void *items; /* the real data */
size_t stride;
}
[k_addon_type_board] = {
.local_content_folder = "boards/",
.cache_stride = sizeof(struct player_board),
- .cache_count = 20
+ .cache_count = 20,
+ .item_arena_size = 1024 * 2
},
[k_addon_type_player] = {
.local_content_folder = "playermodels/",
.cache_stride = sizeof(struct player_model),
- .cache_count = 20
+ .cache_count = 20,
+ .item_arena_size = 1024 * 8
},
[k_addon_type_world] = {
.local_content_folder = "maps/"
#ifdef VG_ENGINE
-struct addon_type_info {
+struct addon_type_info
+{
size_t cache_stride;
+ u32 item_arena_size;
u16 cache_count;
const char *local_content_folder;
}
mdl_load_metadata_block( &ctx, NULL );
mdl_close( &ctx );
- for( u32 i=0; i<af_arrcount( &ctx.meshs ); i ++ )
+ for( u32 i=0; i<ctx.mesh_count; i ++ )
{
- mdl_mesh *mesh = af_arritm( &ctx.meshs, i );
+ mdl_mesh *mesh = &ctx.meshes[ i ];
fprintf( hdr, " %s = %u,\n",
af_str( &ctx.af, mesh->pstr_name ), mesh->submesh_start );
}
static void render_overlay_mesh( enum control_overlay_mesh index )
{
- mdl_draw_submesh( af_arritm( &control_overlay.mdl.submeshs, index ) );
+ mdl_draw_submesh( &control_overlay.mdl.submeshes[ index ] );
}
void control_overlay_init(void)
vg_async_stall();
- if( af_arrcount( &mdl->textures ) )
+ if( mdl->texture_count )
{
- mdl_texture *tex = af_arritm( &mdl->textures, 0 );
+ mdl_texture *tex = &mdl->textures[ 0 ];
control_overlay.tex = tex->glname;
}
else
u32 mtx_size = sizeof(m4x3f)*sk->bone_count;
npc->final_mtx = vg_linear_alloc( vg_mem.rtmemory, mtx_size );
- if( af_arrcount( &meta->textures ) )
+ if( meta->texture_count )
{
- mdl_texture *tex0 = af_arritm( &meta->textures, 0 );
+ mdl_texture *tex0 = &meta->textures[ 0 ];
void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
mdl_fread_pack_file( meta, &tex0->file, data );
vg_linear_clear( vg_mem.scratch );
- if( !af_arrcount( &font->mdl.textures ) )
+ if( !font->mdl.texture_count )
vg_fatal_error( "No texture in font file" );
- mdl_texture *tex0 = af_arritm( &mdl->textures, 0 );
+ mdl_texture *tex0 = &mdl->textures[ 0 ];
void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
mdl_fread_pack_file( mdl, &tex0->file, data );
v4_copy( colour, gui.cur_icon_colour );
}
-static mdl_submesh *gui_find_icon( const char *name ){
+static mdl_submesh *gui_find_icon( const char *name )
+{
mdl_mesh *mesh = mdl_find_mesh( &gui.model_icons, name );
- if( mesh ){
- if( mesh->submesh_count ){
- return af_arritm( &gui.model_icons.submeshs, mesh->submesh_start );
- }
- }
+ if( mesh )
+ if( mesh->submesh_count )
+ return &gui.model_icons.submeshes[ mesh->submesh_start ];
return NULL;
}
gui_find_icon("icon_rift_run_medal_silver");
vg_linear_clear( vg_mem.scratch );
- if( !af_arrcount( &gui.model_icons.textures ) )
+ if( !gui.model_icons.texture_count )
vg_fatal_error( "No texture in menu file" );
- mdl_texture *tex0 = af_arritm( &gui.model_icons.textures, 0 );
+ mdl_texture *tex0 = &gui.model_icons.textures[ 0 ];
void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
mdl_fread_pack_file( &gui.model_icons, &tex0->file, data );
vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
if( out_asoc->entity_type != 28 )
goto NOT_IMPLEMENTED;
- for( u32 j=0; j<af_arrcount( &mdl->armatures ); j ++ )
+ for( u32 j=0; j<mdl->armature_count; j ++ )
{
- mdl_armature *armature = af_arritm( &mdl->armatures, j );
+ mdl_armature *armature = &mdl->armatures[ j ];
if( af_str_eq( &mdl->af, armature->pstr_name, name, name_hash ) )
{
out_asoc->entity_index = j;
mdl_async_full_load_std( &ref->mdl );
mdl_close( &ref->mdl );
- u32 skeleton_count = af_arrcount( &ref->mdl.armatures );
+ u32 skeleton_count = ref->mdl.armature_count;
if( skeleton_count )
{
ref->skeletons = vg_linear_alloc( _cutscene.arena,
u32 armature_id = 0x00;
u32 material_id = 0x00;
- for( u32 i=0; i<af_arrcount( &mdl->meshs ); i ++ )
+ for( u32 i=0; i<mdl->mesh_count; i ++ )
{
- mdl_mesh *mesh = af_arritm( &mdl->meshs, i );
+ mdl_mesh *mesh = &mdl->meshes[ i ];
VG_ASSERT( mesh->armature_id );
if( mesh->armature_id != armature_id )
for( u32 j=0; j<mesh->submesh_count; j ++ )
{
- mdl_submesh *sm = af_arritm( &mdl->submeshs, mesh->submesh_start+j );
+ mdl_submesh *sm = &mdl->submeshes[ mesh->submesh_start+j ];
VG_ASSERT( sm->material_id );
if( sm->material_id != material_id )
{
- mdl_material *m = af_arritm( &mdl->materials, sm->material_id-1 );
+ mdl_material *m = &mdl->materials[ sm->material_id-1 ];
VG_ASSERT( m->shader == k_shader_standard );
struct shader_props_standard *props = m->props.compiled;
VG_ASSERT( props->tex_diffuse );
- mdl_texture *tex = af_arritm( &mdl->textures, props->tex_diffuse-1);
+ mdl_texture *tex = &mdl->textures[ props->tex_diffuse-1 ];
glBindTexture( GL_TEXTURE_2D, tex->glname );
}
void mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
{
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->verts, mdl_vert, lin_alloc );
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->indices, mdl_indice, lin_alloc );
+ struct array_file_ptr ptr;
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_vert, lin_alloc );
+ mdl->verts = ptr.data;
+ mdl->vert_count = ptr.count;
+
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_indice, lin_alloc );
+ mdl->indices = ptr.data;
+ mdl->indice_count = ptr.count;
}
void mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
{
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->meshs, mdl_mesh, lin_alloc );
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->submeshs, mdl_submesh, lin_alloc );
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->textures, mdl_texture, lin_alloc );
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->armatures, mdl_armature, lin_alloc );
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->bones, mdl_bone, lin_alloc );
+ struct array_file_ptr ptr;
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_mesh, lin_alloc );
+ mdl->meshes = ptr.data;
+ mdl->mesh_count = ptr.count;
+
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_submesh, lin_alloc );
+ mdl->submeshes = ptr.data;
+ mdl->submesh_count = ptr.count;
+
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_texture, lin_alloc );
+ mdl->textures = ptr.data;
+ mdl->texture_count = ptr.count;
+
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_armature, lin_alloc );
+ mdl->armatures = ptr.data;
+ mdl->armature_count = ptr.count;
+
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &ptr, mdl_bone, lin_alloc );
+ mdl->bones = ptr.data;
+ mdl->bone_count = ptr.count;
+
mdl_load_materials( mdl, lin_alloc );
}
void mdl_load_materials( mdl_context *mdl, void *lin_alloc )
{
- AF_LOAD_ARRAY_STRUCT( &mdl->af, &mdl->materials, mdl_material, lin_alloc );
+ array_file_ptr mats_ptr;
+ AF_LOAD_ARRAY_STRUCT( &mdl->af, &mats_ptr, mdl_material, lin_alloc );
+ mdl->materials = mats_ptr.data;
+ mdl->material_count = mats_ptr.count;
#if (MDL_VERSION_MIN <= 105)
/* load legacy material data into scratch */
if( !lin_alloc )
return;
- for( u32 i=0; i<af_arrcount(&mdl->materials); i ++ )
+ for( u32 i=0; i<mdl->material_count; i ++ )
{
- mdl_material *mat = af_arritm( &mdl->materials, i );
+ mdl_material *mat = &mdl->materials[ i ];
vg_msg msg;
#if (MDL_VERSION_MIN <= 105)
mdl_mesh *mdl_find_mesh( mdl_context *mdl, const char *name )
{
u32 hash = vg_strdjb2( name );
- for( u32 i=0; i<af_arrcount( &mdl->meshs ); i++ )
+ for( u32 i=0; i<mdl->mesh_count; i++ )
{
- mdl_mesh *mesh = af_arritm( &mdl->meshs, i );
+ mdl_mesh *mesh = &mdl->meshes[ i ];
if( af_str_eq( &mdl->af, mesh->pstr_name, name, hash ) )
return mesh;
}
if( !mesh ) return NULL;
if( !mesh->submesh_count ) return NULL;
- return af_arritm( &mdl->submeshs, mesh->submesh_start );
+ return &mdl->submeshes[ mesh->submesh_start ];
}
#ifdef VG_3D
* ---------------------------------------------------------
*/
- if( af_arrcount( &mdl->submeshs ) )
+ if( mdl->submesh_count )
{
- mdl_submesh *sm = af_arritm( &mdl->submeshs, 0 );
+ mdl_submesh *sm = &mdl->submeshes[ 0 ];
u32 offset = sm->vertex_count;
- for( u32 i=1; i<af_arrcount( &mdl->submeshs ); i++ )
+ for( u32 i=1; i<mdl->submesh_count; i++ )
{
- mdl_submesh *sm = af_arritm( &mdl->submeshs, i );
+ mdl_submesh *sm = &mdl->submeshes[ i ];
u32 *indices = job->indices + sm->indice_start;
for( u32 j=0; j<sm->indice_count; j++ )
{
mdl_async_load_glmesh( mdl, &mdl->mesh, NULL );
- for( u32 i=0; i<af_arrcount( &mdl->textures ); i ++ )
+ for( u32 i=0; i<mdl->texture_count; i ++ )
{
vg_linear_clear( vg_mem.scratch );
- mdl_texture *tex = af_arritm( &mdl->textures, i );
+ mdl_texture *tex = &mdl->textures[ i ];
void *data = vg_linear_alloc( vg_mem.scratch, tex->file.pack_size );
mdl_fread_pack_file( mdl, &tex->file, data );
}
}
+void mdl_sync_std_unload( mdl_context *mdl )
+{
+ mesh_free( &mdl->mesh );
+
+ for( u32 i=0; i<mdl->texture_count; i ++ )
+ {
+ glDeleteTextures( 1, &mdl->textures[i].glname );
+ }
+}
+
#endif
array_file_context af;
u32 version;
- struct array_file_ptr
+ mdl_mesh *meshes;
+ u32 mesh_count;
- /* metadata */
- meshs,
- submeshs,
- materials,
- textures,
- armatures,
- bones,
+ mdl_submesh *submeshes;
+ u32 submesh_count;
- /* mesh buffers */
- verts,
- indices;
+ mdl_material *materials;
+ u32 material_count;
+
+ mdl_texture *textures;
+ u32 texture_count;
+
+ mdl_armature *armatures;
+ u32 armature_count;
+
+ mdl_bone *bones;
+ u32 bone_count;
+
+ mdl_vert *verts;
+ u32 vert_count;
+
+ u32 *indices;
+ u32 indice_count;
u32 pack_base_offset;
/* load textures and mesh */
void mdl_async_full_load_std( mdl_context *mdl );
+void mdl_sync_std_unload( mdl_context *mdl );
/* rendering */
void mdl_draw_submesh( mdl_submesh *sm );
mdl_context *mdl = &player_glide.glider;
mesh_bind( &player_glide.glider.mesh );
- for( u32 i=0; i<af_arrcount(&mdl->meshs); i ++ )
+ for( u32 i=0; i<mdl->mesh_count; i ++ )
{
- mdl_mesh *mesh = af_arritm( &mdl->meshs, i );
+ mdl_mesh *mesh = &mdl->meshes[ i ];
m4x3f mmmdl;
mdl_transform_m4x3( &mesh->transform, mmmdl );
for( u32 j=0; j<mesh->submesh_count; j ++ )
{
- mdl_submesh *sm = af_arritm( &mdl->submeshs, mesh->submesh_start+j );
+ mdl_submesh *sm = &mdl->submeshes[ mesh->submesh_start+j ];
if( !sm->material_id )
{
vg_error( "Invalid material ID 0\n" );
if( sm->material_id != current_mat )
{
- mdl_material *mat = af_arritm( &mdl->materials,sm->material_id-1 );
+ mdl_material *mat = &mdl->materials[ sm->material_id-1 ];
GLuint tex = vg.tex_missing;
if( mat->shader == k_shader_standard )
struct shader_props_standard *props = mat->props.compiled;
u32 index = props->tex_diffuse-1;
- mdl_texture *ptex = af_arritm( &mdl->textures, index );
+ mdl_texture *ptex = &mdl->textures[ index ];
tex = ptex->glname;
}
sizeof(m4x3f)*NETWORK_MAX_PLAYERS );
}
-/* TODO: Standard model load */
-
-void dynamic_model_load( mdl_context *ctx,
- struct dynamic_model_1texture *mdl,
- const char *path, u32 *fixup_table )
-{
- if( !af_arrcount( &ctx->textures ) )
- vg_fatal_error( "No texture in model" );
-
- mdl_texture *tex0 = af_arritm( &ctx->textures, 0 );
- void *data = vg_linear_alloc( vg_mem.scratch, tex0->file.pack_size );
- mdl_fread_pack_file( ctx, &tex0->file, data );
-
- vg_tex2d_load_qoi_async( data, tex0->file.pack_size,
- VG_TEX2D_NEAREST|VG_TEX2D_CLAMP,
- &mdl->texture );
-
- mdl_async_load_glmesh( ctx, &mdl->mesh, fixup_table );
-}
-
-void dynamic_model_unload( struct dynamic_model_1texture *mdl )
-{
- mesh_free( &mdl->mesh );
- glDeleteTextures( 1, &mdl->texture );
-}
-
/* TODO: allow error handling */
-void player_board_load( struct player_board *board, const char *path )
+void player_board_load( player_board *board, const char *path, void *arena )
{
- 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, NULL );
+ mdl_open( &board->mdl, path, arena );
+ mdl_load_metadata_block( &board->mdl, arena );
+ mdl_async_full_load_std( &board->mdl );
array_file_ptr markers;
- AF_LOAD_ARRAY_STRUCT( &ctx.af, &markers, ent_marker, vg_mem.scratch );
+ AF_LOAD_ARRAY_STRUCT( &board->mdl.af, &markers, ent_marker, vg_mem.scratch );
/* TODO: you get put into a new section, the above is standard mdl loads. */
for( int i=0; i<4; i++ )
board->trucks[i].indice_count = 0;
board->board.indice_count = 0;
- for( u32 i=0; i<af_arrcount(&ctx.meshs); i++ ){
- mdl_mesh *mesh = af_arritm( &ctx.meshs, i );
+ for( u32 i=0; i<board->mdl.mesh_count; i++ )
+ {
+ mdl_mesh *mesh = &board->mdl.meshes[ i ];
if( mdl_entity_id_type( mesh->entity_id ) != k_ent_marker )
continue;
u32 index = mdl_entity_id_id( mesh->entity_id );
ent_marker *marker = af_arritm( &markers, index );
- mdl_submesh *sm0 = af_arritm( &ctx.submeshs, mesh->submesh_start );
+ mdl_submesh *sm0 = &board->mdl.submeshes[ mesh->submesh_start ];
- const char *alias = af_str( &ctx.af, marker->pstr_alias );
+ const char *alias = af_str( &board->mdl.af, marker->pstr_alias );
u32 lr = marker->transform.co[0] > 0.0f? 1: 0,
fb = marker->transform.co[2] > 0.0f? 0: 1;
}
}
- mdl_close( &ctx );
+ mdl_close( &board->mdl );
}
void player_board_unload( struct player_board *board )
{
- dynamic_model_unload( &board->mdl );
+ VG_ASSERT( vg_thread_purpose() == k_thread_purpose_main );
+ mdl_sync_std_unload( &board->mdl );
}
-void player_model_load( struct player_model *board, const char *path)
+void player_model_load( player_model *pm, const char *path, void *arena )
{
- vg_linear_clear( vg_mem.scratch );
+ mdl_open( &pm->mdl, path, arena );
+ mdl_load_metadata_block( &pm->mdl, arena );
+ mdl_async_full_load_std( &pm->mdl );
- mdl_context ctx;
- mdl_open( &ctx, path, vg_mem.scratch );
- mdl_load_metadata_block( &ctx, vg_mem.scratch );
-
- if( !ctx.armatures.count )
- vg_fatal_error( "No armature in playermodel\n" );
-
- mdl_armature *armature = af_arritm( &ctx.armatures, 0 );
+ VG_ASSERT( pm->mdl.armature_count );
+ mdl_armature *armature = &pm->mdl.armatures[ 0 ];
u32 fixup_table[ armature->bone_count+1 ];
for( u32 i=0; i<armature->bone_count+1; i ++ )
for( u32 j=1; j<armature->bone_count; j ++ )
{
- mdl_bone *bone = af_arritm( &ctx.bones, armature->bone_start+j );
+ mdl_bone *bone = &pm->mdl.bones[ armature->bone_start+j ];
- if( af_str_eq( &ctx.af, bone->pstr_name, sb->name, hash ) )
+ if( af_str_eq( &pm->mdl.af, bone->pstr_name, sb->name, hash ) )
{
fixup_table[j+1] = i;
break;
}
}
- dynamic_model_load( &ctx, &board->mdl, path, fixup_table );
- mdl_close( &ctx );
+ mdl_close( &pm->mdl );
}
-void player_model_unload( struct player_model *board )
+void player_model_unload( player_model *pm )
{
- dynamic_model_unload( &board->mdl );
+ VG_ASSERT( vg_thread_purpose() == k_thread_purpose_main );
+ mdl_sync_std_unload( &pm->mdl );
}
void apply_full_skeleton_pose( struct skeleton *sk, player_pose *pose,
v3f inverse;
+ VG_ASSERT( board->mdl.texture_count );
+
glActiveTexture( GL_TEXTURE0 );
- glBindTexture( GL_TEXTURE_2D, board->mdl.texture );
+ glBindTexture( GL_TEXTURE_2D, board->mdl.textures[0].glname );
if( shader == k_board_shader_player )
{
void render_playermodel( vg_camera *cam, world_instance *world,
int depth_compare,
- struct player_model *model,
+ player_model *model,
struct skeleton *skeleton,
m4x3f *final_mtx )
{
shader_model_character_view_use();
glActiveTexture( GL_TEXTURE0 );
- glBindTexture( GL_TEXTURE_2D, model->mdl.texture );
+ VG_ASSERT( model->mdl.texture_count );
+ glBindTexture( GL_TEXTURE_2D, model->mdl.textures[0].glname );
+
shader_model_character_view_uTexMain( 0 );
shader_model_character_view_uCamera( cam->transform[3] );
shader_model_character_view_uPv( cam->mtx.pv );
k_board_wheel_br = 3,
};
-/* TODO: Fully featured dynamic models
- * This is FAR from the final system we want at all, but it will do for now */
-struct dynamic_model_1texture{
- glmesh mesh;
- GLuint texture;
-};
-
-struct player_board{
- struct dynamic_model_1texture mdl;
+typedef struct player_board player_board;
+struct player_board
+{
+ mdl_context mdl;
v4f wheel_positions[4],
truck_positions[2],
board;
};
-struct player_model{
- struct dynamic_model_1texture mdl;
+typedef struct player_model player_model;
+struct player_model
+{
+ mdl_context mdl;
};
enum board_shader{
k_board_shader_entity
};
-void dynamic_model_load( mdl_context *ctx,
- struct dynamic_model_1texture *mdl,
- const char *path, u32 *fixup_table );
-void dynamic_model_unload( struct dynamic_model_1texture *mdl );
-
-void player_board_load( struct player_board *mdl, const char *path );
-void player_board_unload( struct player_board *mdl );
+void player_board_load( player_board *board, const char *path, void *arena );
+void player_board_unload( player_board *mdl );
-void player_model_load( struct player_model *board, const char *path);
-void player_model_unload( struct player_model *board );
+void player_model_load( player_model *pm, const char *path, void *arena );
+void player_model_unload( player_model *pm );
void render_board( vg_camera *cam, world_instance *world,
- struct player_board *board, m4x3f root,
+ player_board *board, m4x3f root,
struct player_board_pose *pose,
enum board_shader shader );
void render_playermodel( vg_camera *cam, world_instance *world,
int depth_compare,
- struct player_model *model,
+ player_model *model,
struct skeleton *skeleton,
m4x3f *final_mtx );
void apply_full_skeleton_pose( struct skeleton *sk, player_pose *pose,
ctx->max_indices );
}
- mdl_vert *src_verts = af_arritm( &mdl->verts, sm->vertex_start );
+ mdl_vert *src_verts = mdl->verts + sm->vertex_start;
scene_vert *dst_verts = &ctx->arrvertices[ ctx->vertex_count ];
- u32 *src_indices = af_arritm( &mdl->indices, sm->indice_start ),
+ u32 *src_indices = mdl->indices + sm->indice_start,
*dst_indices = &ctx->arrindices[ ctx->indice_count ];
/* Transform and place vertices */
player_load_animation_reference( "models/ch_none.mdl" );
player_load_animations( "metascenes/skater.ms" );
- player_model_load( &localplayer.fallback_model, "models/ch_none.mdl" );
+ player_model_load( &localplayer.fallback_model, "models/ch_none.mdl",
+ vg_mem.rtmemory );
player__bind();
- player_board_load( &localplayer.fallback_board, "models/board_none.mdl" );
+ player_board_load( &localplayer.fallback_board, "models/board_none.mdl",
+ vg_mem.rtmemory );
}
void game_load(void)
for( u32 i=0; i<armature->bone_count; i++ )
{
- mdl_bone *bone = af_arritm( &mdl->bones, armature->bone_start+i );
+ mdl_bone *bone = &mdl->bones[ armature->bone_start+i ];
if( bone->flags & k_bone_flag_ik )
skele->ik_count ++;
u32 bone_size = sizeof(struct skeleton_bone) * skele->bone_count,
ik_size = sizeof(struct skeleton_ik) * skele->ik_count;
- skele->bones = vg_linear_alloc( lin_alloc, bone_size );
- skele->ik = vg_linear_alloc( lin_alloc, ik_size );
+ skele->bones = vg_linear_alloc( lin_alloc, bone_size );
+ skele->ik = vg_linear_alloc( lin_alloc, ik_size );
memset( skele->bones, 0, bone_size );
memset( skele->ik, 0, ik_size );
skele->bone_count = 0;
skele->bones = NULL;
- if( !mdl->armatures.count )
+ if( !mdl->armature_count )
{
vg_error( "No skeleton in model\n" );
skeleton_fatal_err();
}
- mdl_armature *armature = af_arritm( &mdl->armatures, index );
+ mdl_armature *armature = &mdl->armatures[ index ];
skeleton_alloc_from( skele, lin_alloc, mdl, armature );
for( u32 i=0; i<armature->bone_count; i++ )
{
- mdl_bone *bone = af_arritm( &mdl->bones, armature->bone_start+i );
+ mdl_bone *bone = &mdl->bones[ armature->bone_start+i ];
struct skeleton_bone *sb = &skele->bones[i+1];
v3_copy( bone->co, sb->co );
return;
}
+ if( workshop_form.model_arena == NULL )
+ {
+ workshop_form.model_arena = _vg_create_linear_allocator(
+ NULL, 1024*2, VG_MEMORY_SYSTEM, "Workshop model data arena" );
+ }
+ void *arena = workshop_form.model_arena;
+ vg_linear_clear( arena );
+
if( workshop_form.submission.type == k_addon_type_board )
- player_board_load( &workshop_form.board_model, path_buf );
+ {
+ player_board_load( &workshop_form.board_model, path_buf, arena );
+ }
else if( workshop_form.submission.type == k_addon_type_player )
- player_model_load( &workshop_form.player_model, path_buf );
+ {
+ player_model_load( &workshop_form.player_model, path_buf, arena );
+ }
vg_async_call( workshop_form_loadmodel_async_complete, NULL, 0 );
}
*/
char addon_folder[128];
+ void *model_arena;
struct player_board board_model;
struct player_model player_model;
boxf box;
box_init_inf( box );
- for( u32 i=0; i<objective->submesh_count; i++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- objective->submesh_start+i );
+ for( u32 i=0; i<objective->submesh_count; i++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ objective->submesh_start+i ];
box_concat( box, sm->bbx );
}
boxf box;
box_init_inf( box );
- for( u32 i=0; i<objective->submesh_count; i++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- objective->submesh_start+i );
+ for( u32 i=0; i<objective->submesh_count; i++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ objective->submesh_start+i ];
box_concat( box, sm->bbx );
}
mdl_load_metadata_block( &mgate, vg_mem.scratch );
mdl_mesh *surface = mdl_find_mesh( &mgate, "rs_gate" );
- mdl_submesh *sm = af_arritm(&mgate.submeshs,surface->submesh_start);
+ mdl_submesh *sm = &mgate.submeshes[ surface->submesh_start ];
world_gates.sm_surface = *sm;
const char *names[] = { "rs_gate_marker", "rs_gate_marker.001",
"rs_gate_marker.002", "rs_gate_marker.003" };
- for( int i=0; i<4; i++ ){
+ for( int i=0; i<4; i++ )
+ {
mdl_mesh *marker = mdl_find_mesh( &mgate, names[i] );
- sm = af_arritm( &mgate.submeshs, marker->submesh_start );
+ sm = &mgate.submeshes[ marker->submesh_start ];
world_gates.sm_marker[i] = *sm;
}
static void render_gate_mesh( world_instance *world, ent_gate *gate )
{
- if( gate->flags & k_ent_gate_custom_mesh ){
+ if( gate->flags & k_ent_gate_custom_mesh )
+ {
mesh_bind( &world->mesh_no_collide );
- for( u32 i=0; i<gate->submesh_count; i++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- gate->submesh_start+i );
+ for( u32 i=0; i<gate->submesh_count; i++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ gate->submesh_start+i ];
mdl_draw_submesh( sm );
}
}
- else {
+ else
+ {
mesh_bind( &world_gates.mesh );
mdl_draw_submesh( &world_gates.sm_surface );
}
static void world_add_all_if_material( m4x3f transform, scene_context *scene,
mdl_context *mdl, u32 id )
{
- for( u32 i=0; i<af_arrcount(&mdl->meshs); i++ ){
- mdl_mesh *mesh = af_arritm( &mdl->meshs, i );
+ for( u32 i=0; i<mdl->mesh_count; i++ )
+ {
+ mdl_mesh *mesh = &mdl->meshes[ i ];
- for( u32 j=0; j<mesh->submesh_count; j++ ){
- mdl_submesh *sm = af_arritm( &mdl->submeshs, mesh->submesh_start+j );
- if( sm->material_id == id ){
+ for( u32 j=0; j<mesh->submesh_count; j++ )
+ {
+ mdl_submesh *sm = &mdl->submeshes[ mesh->submesh_start+j ];
+ if( sm->material_id == id )
+ {
m4x3f transform2;
mdl_transform_m4x3( &mesh->transform, transform2 );
m4x3_mul( transform, transform2, transform2 );
* models. we only have 2 types at the moment which need dynamic models but
* would make sense to do this when/if we have more.
*/
- for( u32 i=0; i<af_arrcount( &world->ent_traffic ); i++ ){
+ for( u32 i=0; i<af_arrcount( &world->ent_traffic ); i++ )
+ {
ent_traffic *vehc = af_arritm( &world->ent_traffic, i );
- for( u32 j=0; j<vehc->submesh_count; j++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- vehc->submesh_start+j );
+ for( u32 j=0; j<vehc->submesh_count; j++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ vehc->submesh_start+j ];
world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
world->surfaces[ sm->material_id ].flags |= WORLD_SURFACE_HAS_TRAFFIC;
}
}
/* unpack challenge models */
- for( u32 i=0; i<af_arrcount( &world->ent_objective ); i++ ){
+ for( u32 i=0; i<af_arrcount( &world->ent_objective ); i++ )
+ {
ent_objective *objective = af_arritm( &world->ent_objective, i );
- for( u32 j=0; j<objective->submesh_count; j ++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- objective->submesh_start+j );
+ for( u32 j=0; j<objective->submesh_count; j ++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ objective->submesh_start+j ];
world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
}
}
for( u32 i=0; i<af_arrcount( &world->ent_region ); i++ ){
ent_region *region = af_arritm( &world->ent_region, i );
- for( u32 j=0; j<region->submesh_count; j ++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- region->submesh_start+j );
+ for( u32 j=0; j<region->submesh_count; j ++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ region->submesh_start+j ];
world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
}
}
/* unpack gate models */
- for( u32 i=0; i<af_arrcount( &world->ent_gate ); i++ ){
+ for( u32 i=0; i<af_arrcount( &world->ent_gate ); i++ )
+ {
ent_gate *gate = af_arritm( &world->ent_gate, i );
-
if( !(gate->flags & k_ent_gate_custom_mesh) ) continue;
- for( u32 j=0; j<gate->submesh_count; j ++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- gate->submesh_start+j );
+ for( u32 j=0; j<gate->submesh_count; j ++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ gate->submesh_start+j ];
world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
}
}
/* unpack prop models */
- for( u32 i=0; i<af_arrcount( &world->ent_prop ); i++ ){
+ for( u32 i=0; i<af_arrcount( &world->ent_prop ); i++ )
+ {
ent_prop *prop = af_arritm( &world->ent_prop, i );
- for( u32 j=0; j<prop->submesh_count; j ++ ){
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- prop->submesh_start+j );
+ for( u32 j=0; j<prop->submesh_count; j ++ )
+ {
+ mdl_submesh *sm = &world->meta.submeshes[ prop->submesh_start+j ];
world->surfaces[ sm->material_id ].flags |= WORLD_SURFACE_HAS_PROPS;
world_unpack_submesh_dynamic( world, &world->scene_no_collide, sm );
}
vg_info( "Loading textures\n" );
world->texture_count = 0;
- world->texture_count = world->meta.textures.count+1;
+ world->texture_count = world->meta.texture_count+1;
world->textures = vg_linear_alloc( world->heap,
vg_align8(sizeof(GLuint)*world->texture_count) );
world->textures[0] = vg.tex_missing;
- for( u32 i=0; i<af_arrcount(&world->meta.textures); i++ )
+ for( u32 i=0; i<world->meta.texture_count; i++ )
{
- mdl_texture *tex = af_arritm( &world->meta.textures, i );
+ mdl_texture *tex = &world->meta.textures[ i ];
if( !tex->file.pack_size )
{
vg_info( "Loading materials\n" );
- world->surface_count = world->meta.materials.count+1;
+ world->surface_count = world->meta.material_count+1;
world->surfaces = vg_linear_alloc( world->heap,
vg_align8(sizeof(struct world_surface)*world->surface_count) );
struct world_surface *errmat = &world->surfaces[0];
memset( errmat, 0, sizeof(struct world_surface) );
- for( u32 i=0; i<af_arrcount(&world->meta.materials); i++ )
+ for( u32 i=0; i<world->meta.material_count; i++ )
{
struct world_surface *surf = &world->surfaces[i+1];
- surf->info = *(mdl_material *)af_arritm( &world->meta.materials, i );
+ surf->info = world->meta.materials[ i ];
surf->flags = 0;
if( surf->info.shader == k_shader_water )
{
for( u32 k=0; k<count; k++ )
{
- mdl_submesh *sm = af_arritm( &world->meta.submeshs, start+k );
+ mdl_submesh *sm = &world->meta.submeshes[ start+k ];
if( sm->material_id != material_id )
continue;
for( u32 j=0; j<objective->submesh_count; j++ )
{
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- objective->submesh_start + j );
+ mdl_submesh *sm = &world->meta.submeshes[objective->submesh_start + j];
if( sm->material_id != last_material )
{
for( u32 j=0; j<region->submesh_count; j++ )
{
- mdl_submesh *sm = af_arritm( &world->meta.submeshs,
- region->submesh_start + j );
+ mdl_submesh *sm = &world->meta.submeshes[region->submesh_start + j];
if( sm->material_id != last_material )
{
*m_card = mdl_find_mesh( &mscoreboard, "score_card" );
mdl_submesh
- *sm_backer = af_arritm( &mscoreboard.submeshs, m_backer->submesh_start ),
- *sm_card = af_arritm( &mscoreboard.submeshs, m_card->submesh_start );
+ *sm_backer = &mscoreboard.submeshes[ m_backer->submesh_start ],
+ *sm_card = &mscoreboard.submeshes[ m_card->submesh_start ];
world_sfd.sm_base = *sm_backer;
m4x3f identity;
projects / carveJwlIkooP6JGAAIwe30JlM.git / commitdiff