#include "skaterift.h"
-#define MDL_VERSION_NR 101
+#define MDL_VERSION_MIN 101
+#define MDL_VERSION_NR 103
-enum mdl_shader
-{
+enum mdl_shader{
k_shader_standard = 0,
k_shader_standard_cutout = 1,
k_shader_terrain_blend = 2,
k_shader_standard_vertex_blend = 3,
k_shader_water = 4,
k_shader_invisible = 5,
- k_shader_boundary = 6
+ k_shader_boundary = 6,
+ k_shader_fxglow = 7,
+ k_shader_cubemap = 8,
+ k_shader_override = 30000
};
-enum mdl_surface_prop
-{
+enum mdl_surface_prop{
k_surface_prop_concrete = 0,
k_surface_prop_wood = 1,
k_surface_prop_grass = 2,
k_surface_prop_metal = 4
};
-enum material_flag
-{
- k_material_flag_skate_target = 0x00000001,
- k_material_flag_collision = 0x00000002,
- k_material_flag_grow_grass = 0x00000004,
- k_material_flag_grindable = 0x00000008,
- k_material_flag_invisible = 0x00000010,
- k_material_flag_boundary = 0x00000020,
- k_material_flag_preview_visibile = 0x00000040
+enum material_flag{
+ k_material_flag_skate_target = 0x0001,
+ k_material_flag_collision = 0x0002,
+ k_material_flag_grow_grass = 0x0004,
+ k_material_flag_grindable = 0x0008,
+ k_material_flag_invisible = 0x0010,
+ k_material_flag_boundary = 0x0020,
+ k_material_flag_preview_visibile = 0x0040,
+ k_material_flag_walking = 0x0080,
+
+ k_material_flag_ghosts =
+ k_material_flag_boundary|
+ k_material_flag_invisible|
+ k_material_flag_walking
};
#pragma pack(push,1)
};
-VG_STATIC void mdl_load_fatal_corrupt( mdl_context *mdl )
+static void mdl_load_fatal_corrupt( mdl_context *mdl )
{
fclose( mdl->file );
vg_file_print_invalid( mdl->file );
* Model implementation
*/
-VG_STATIC u32 mdl_query_array_size( mdl_array *arr )
+static u32 mdl_query_array_size( mdl_array *arr )
{
if( arr->item_count ){
u32 size = arr->item_size*arr->item_count;
else return 0;
}
-VG_STATIC const char *mdl_pstr( mdl_context *mdl, u32 pstr );
-VG_STATIC
+static const char *mdl_pstr( mdl_context *mdl, u32 pstr );
+static
void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst )
{
if( !info->pack_size ){
}
/* TODO: Rename these */
-VG_STATIC void mdl_load_array_file_buffer( mdl_context *mdl, mdl_array *arr,
+static void mdl_load_array_file_buffer( mdl_context *mdl, mdl_array *arr,
void *buffer )
{
if( arr->item_count ){
}
}
-VG_STATIC void mdl_load_array_file( mdl_context *mdl, mdl_array_ptr *ptr,
+static void mdl_load_array_file( mdl_context *mdl, mdl_array_ptr *ptr,
mdl_array *arr, void *lin_alloc )
{
if( arr->item_count ){
ptr->stride = arr->item_size;
}
-VG_STATIC void *mdl_arritm( mdl_array_ptr *arr, u32 index )
+static void *mdl_arritm( mdl_array_ptr *arr, u32 index )
{
return ((u8 *)arr->data) + index*arr->stride;
}
-VG_STATIC u32 mdl_arrcount( mdl_array_ptr *arr )
+static u32 mdl_arrcount( mdl_array_ptr *arr )
{
return arr->count;
}
-VG_STATIC mdl_array *mdl_find_array( mdl_context *mdl, const char *name )
+static mdl_array *mdl_find_array( mdl_context *mdl, const char *name )
{
for( u32 i=0; i<mdl_arrcount(&mdl->index); i++ ){
mdl_array *arr = mdl_arritm( &mdl->index, i );
return NULL;
}
-VG_STATIC int mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
+static int mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
const char *name, void *lin_alloc )
{
mdl_array *arr = mdl_find_array( mdl, name );
}
}
-VG_STATIC int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
+static int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
{
int success = 1;
return success;
}
-VG_STATIC int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
+static int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
{
int success = 1;
return success;
}
-VG_STATIC int mdl_load_animation_block( mdl_context *mdl, void *lin_alloc )
+static int mdl_load_animation_block( mdl_context *mdl, void *lin_alloc )
{
return mdl_load_array( mdl, &mdl->keyframes, "mdl_keyframe", lin_alloc );
}
/*
* if calling mdl_open, and the file does not exist, the game will fatal quit
*/
-VG_STATIC void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
+static void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
{
memset( mdl, 0, sizeof( mdl_context ) );
mdl->file = fopen( path, "rb" );
if( l != 1 )
mdl_load_fatal_corrupt( mdl );
- if( mdl->info.version < MDL_VERSION_NR ){
+ if( mdl->info.version < MDL_VERSION_MIN ){
vg_warn( "For model: %s\n", path );
- vg_warn( " version: %u (current: %u)\n", mdl->info.version,
- MDL_VERSION_NR );
+ vg_warn( " version: %u (min: %u, current: %u)\n",
+ mdl->info.version, MDL_VERSION_MIN, MDL_VERSION_NR );
vg_fatal_error( "Legacy model version incompatable" );
}
/*
* close file handle
*/
-VG_STATIC void mdl_close( mdl_context *mdl )
+static void mdl_close( mdl_context *mdl )
{
fclose( mdl->file );
mdl->file = NULL;
/* useful things you can do with the model */
-VG_STATIC void mdl_transform_m4x3( mdl_transform *transform, m4x3f mtx )
+static void mdl_transform_m4x3( mdl_transform *transform, m4x3f mtx )
{
q_m3x3( transform->q, mtx );
v3_muls( mtx[0], transform->s[0], mtx[0] );
v3_copy( transform->co, mtx[3] );
}
-VG_STATIC const char *mdl_pstr( mdl_context *mdl, u32 pstr )
+static const char *mdl_pstr( mdl_context *mdl, u32 pstr )
{
return ((char *)mdl_arritm( &mdl->strings, pstr )) + 4;
}
-VG_STATIC int
+static int
mdl_pstreq( mdl_context *mdl, u32 pstr, const char *str, u32 djb2 )
{
u32 hash = *((u32 *)mdl_arritm( &mdl->strings, pstr ));
* ----------------------------------------------------------------------------
*/
-VG_STATIC void mesh_upload( glmesh *mesh,
+static void mesh_upload( glmesh *mesh,
mdl_vert *verts, u32 vert_count,
u32 *indices, u32 indice_count )
{
mesh->loaded = 1;
}
-VG_STATIC void mesh_bind( glmesh *mesh )
+static void mesh_bind( glmesh *mesh )
{
glBindVertexArray( mesh->vao );
}
-VG_STATIC void mesh_drawn( u32 start, u32 count )
+static void mesh_drawn( u32 start, u32 count )
{
glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT,
(void *)(start*sizeof(u32)) );
}
-VG_STATIC void mesh_draw( glmesh *mesh )
+static void mesh_draw( glmesh *mesh )
{
mesh_drawn( 0, mesh->indice_count );
}
-VG_STATIC void mesh_free( glmesh *mesh )
+static void mesh_free( glmesh *mesh )
{
if( mesh->loaded ){
glDeleteVertexArrays( 1, &mesh->vao );
}
}
-VG_STATIC void mdl_draw_submesh( mdl_submesh *sm )
+static void mdl_draw_submesh( mdl_submesh *sm )
{
mesh_drawn( sm->indice_start, sm->indice_count );
}
-VG_STATIC mdl_mesh *mdl_find_mesh( mdl_context *mdl, const char *name )
+static mdl_mesh *mdl_find_mesh( mdl_context *mdl, const char *name )
{
for( u32 i=0; i<mdl_arrcount( &mdl->meshs ); i++ ){
mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
glmesh *mesh;
};
-VG_STATIC void async_mdl_load_glmesh( void *payload, u32 size )
+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,
}
/* 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 )
+static void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh )
{
mdl_array *arr_vertices = mdl_find_array( mdl, "mdl_vert" );
mdl_array *arr_indices = mdl_find_array( mdl, "mdl_indice" );
}
/* uploads the glmesh, and textures. everything is saved into the mdl_context */
-VG_STATIC void mdl_async_full_load_std( mdl_context *mdl ){
+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 ++ ){
projects / carveJwlIkooP6JGAAIwe30JlM.git / blobdiff