#include <stdio.h>
#include <string.h>
#include <math.h>
+#include <time.h>
// CSR lib
#include "csrTypes.h"
// Valve formats
#include "vdf.h"
#include "vpk.h"
+#include "vfilesys.h"
+
#include "vmdl.h"
#include "vmf.h"
-#include "vfilesys.h"
// CSR main
#include "csrDraw.h"
int main( int argc, char *argv[] )
{
- vmf_vert *triangles = NULL;
- vmf_vert oh_yeah_yeah = {0};
-
- for( int i = 0; i < 22; i ++ )
- {
- triangles = csr_sb_reserve( triangles, 3, sizeof( vmf_vert ) );
-
- vmf_vert *tri = triangles + csr_sb_count( triangles );
-
- tri[0] = oh_yeah_yeah;
- tri[1] = oh_yeah_yeah;
- tri[2] = oh_yeah_yeah;
-
- csr_sb_inc( triangles, 3 );
- }
-
if( argc == 2 )
{
+ fs_set_gameinfo( "/home/harry/SteamLibrary/steamapps/common/Counter-Strike Global Offensive/csgo/gameinfo.txt" );
printf( "read: %s\n", argv[1] );
- vdf_node *node = vdf_open_file( argv[1] );
+ //vdf_node *node = vdf_open_file( argv[1] );
+ vmf_map *map = vmf_init( argv[1], 1 );
+ vmf_free( map );
+ fs_exit();
+
+ /*
vmf_solid solid_main;
{
solidgen_push( &solid_main, brush );
}
-
- vmf_vert *triangles = NULL;
+
+ clock_t t;
+ t = clock();
+ printf("Timer starts\n");
+
+ csr_frag *image = (csr_frag *)csr_malloc( 1024*1024*sizeof(csr_frag) );
+ clear_depth( image, 1024, 1024 );
for( int i = 0; i < csr_sb_count( solid_main.indices )/3; i ++ )
{
u32 * base = solid_main.indices + i*3;
- triangles = csr_sb_reserve( triangles, 3, sizeof( vmf_vert ) );
-
- vmf_vert *tri = triangles + csr_sb_count( triangles );
+ vmf_vert tri[3];
tri[0] = solid_main.verts[ base[0] ];
tri[1] = solid_main.verts[ base[1] ];
tri[2] = solid_main.verts[ base[2] ];
-
- csr_sb_inc( triangles, 3 );
+
+ draw_buffers( image, 1024, 1024, (v4f){ -1000.f, -1000.f, 1000.f, 1000.f }, tri, 1 );
}
- csr_frag *image = (csr_frag *)csr_malloc( 1024*1024*sizeof(csr_frag) );
- draw_buffers( image, 1024, 1024, (v4f){ -1000.f, -1000.f, 1000.f, 1000.f }, triangles, csr_sb_count( triangles )/3 );
+ printf("Timer ends \n");
+ t = clock() - t;
+ double time_taken = ((double)t)/CLOCKS_PER_SEC; // calculate the elapsed time
+ printf("Tracing took %f seconds to execute\n", time_taken);
float *rgba_test = (float *)csr_malloc( 1024*1024*sizeof(float)*3 );
free( rgba_test );
free( image );
- csr_sb_free( triangles );
solidgen_to_obj( &solid_main, "hello.obj" );
vdf_free_r( node );
+ */
}
}
-#include "csrTypes.h"
-#include "csrComb.h"
-
#define SOLID_MAX_SIDES 512
typedef struct vmf_solid vmf_solid;
typedef struct vmf_vert vmf_vert;
typedef struct vmf_mat vmf_mat;
typedef struct vmf_face vmf_face;
+typedef struct vmf_userdata vmf_userdata;
+typedef struct vmf_map vmf_map;
typedef enum ESolidResult ESolidResult;
u32 hash;
};
+struct vmf_map
+{
+ vdf_node *root;
+
+ struct vmf_model
+ {
+ char *str;
+ u32 hash;
+
+ mdl_mesh_t mdl;
+ }
+ *models;
+
+ struct vmf_instance
+ {
+ char *name;
+ u32 hash;
+
+ vdf_node *root;
+ }
+ *cache;
+};
+
// IMPLEMENTATION
void solidgen_ctx_init( vmf_solid *ctx )
return flag;
}
+u32 vmf_get_mdl( vmf_map *map, const char *mdl )
+{
+ u32 hash = djb2( (const unsigned char *)mdl );
+
+ for( u32 i = 0; i < csr_sb_count( map->models ); i ++ )
+ {
+ if( hash == map->models[i].hash && !strcmp( map->models[i].str, mdl ) )
+ {
+ return i;
+ }
+ }
+
+ return 0;
+}
+
+void vmf_populate_models( vdf_node *vmf, vmf_map *map )
+{
+ vdf_foreach( vmf, "entity", ent )
+ {
+ // Use any class name with prop_
+ if( !strncmp( kv_get( ent, "classname", "" ), "prop_", 5 ))
+ {
+ // Check if it exists
+ const char *model_path = kv_get( ent, "model", "" );
+ u32 mdl_id = vmf_get_mdl( map, model_path );
+
+ if( !mdl_id )
+ {
+ map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
+
+ struct vmf_model *entry = &map->models[ csr_sb_count( map->models ) ];
+ entry->str = csr_malloc( strlen( model_path ) +1 );
+ strcpy( entry->str, model_path );
+ entry->hash = djb2( (const unsigned char *)model_path );
+
+ mdl_id = csr_sb_count( map->models );
+ csr_sb_use( map->models );
+ }
+
+ // Assign prop-ID for later use
+ ent->user = mdl_id;
+ }
+ }
+}
+
+// Load all models
+void vmf_load_models( vmf_map *map )
+{
+ printf( "Loading all models\n" );
+
+ // Error model. TODO: Maybe don't have this be junk data.
+ map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
+ csr_sb_use( map->models );
+ mdl_error( &map->models[0].mdl );
+
+ // Create listings for each model
+ vmf_populate_models( map->root, map );
+
+ for( int i = 0; i < csr_sb_count( map->cache ); i ++ )
+ {
+ vmf_populate_models( map->cache[i].root, map );
+ }
+
+ printf( "Indexed (%u) models\n", csr_sb_count( map->models ) );
+
+ u32 num_success = 0;
+
+ // Load model data
+ // TODO: Make nice loading bar
+ for( int i = 1; i < csr_sb_count( map->models ); i ++ )
+ {
+ printf( "Load model (%d)\n", i );
+
+ struct vmf_model *mdl = &map->models[i];
+
+ if( mdl_from_find_files( mdl->str, &mdl->mdl ) )
+ {
+ num_success ++;
+ }
+ }
+
+ printf( "Done (%u of %u loaded)\n", num_success, csr_sb_count( map->models ) );
+}
+
+void vmf_init_subvmf( vmf_map *map, const char *subvmf );
+
+void vmf_load_all_instances( vmf_map *map, vdf_node *vmf )
+{
+ vdf_foreach( vmf, "entity", ent )
+ {
+ if( !strcmp( kv_get( ent, "classname", "" ), "func_instance" ))
+ {
+ // Entity is in use if file is specified, if not just ignore the entity.
+ const char *path = kv_get( ent, "file", "" );
+ if( strcmp( path, "" ) )
+ {
+ vmf_init_subvmf( map, path );
+ }
+ }
+ }
+}
+
+void vmf_init_subvmf( vmf_map *map, const char *subvmf )
+{
+ printf( "Loading subvmf: %s\n", subvmf );
+
+ u32 hash = djb2( (const unsigned char *)subvmf );
+
+ // Check if present
+ for( int i = 0; i < csr_sb_count( map->cache ); i ++ )
+ {
+ if( hash == map->cache[i].hash )
+ {
+ if( !strcmp( map->cache[i].name, subvmf ) )
+ {
+ return;
+ }
+ }
+ }
+
+ map->cache = csr_sb_reserve( map->cache, 1, sizeof( struct vmf_instance ));
+ struct vmf_instance *inst = &map->cache[ csr_sb_count( map->cache ) ];
+
+ if( (inst->root = vdf_open_file( subvmf )) )
+ {
+ csr_sb_use( map->cache );
+
+ inst->hash = hash;
+ inst->name = csr_malloc( strlen( subvmf )+1 );
+ strcpy( inst->name, subvmf );
+
+ // Recursive load other instances
+ vmf_load_all_instances( map, inst->root );
+ }
+ else
+ {
+ // TODO: Don't die here?
+ fprintf( stderr, "Failed to load instance file\n" );
+ exit(0);
+ }
+}
+
+vmf_map *vmf_init( const char *path, int load_models )
+{
+ vmf_map *map = csr_calloc( sizeof( vmf_map ) );
+ map->root = vdf_open_file( path );
+
+ // Prepare instances
+ vmf_load_all_instances( map, map->root );
+
+ // Other resources
+ if( load_models )
+ {
+ vmf_load_models( map );
+ }
+
+ return map;
+}
+
+void vmf_free( vmf_map *map )
+{
+ for( int i = 0; i < csr_sb_count( map->cache ); i ++ )
+ {
+ vdf_free_r( map->cache[i].root );
+ free( map->cache[i].name );
+ }
+
+ for( int i = 1; i < csr_sb_count( map->models ); i ++ )
+ {
+ free( map->models[i].str );
+ mdl_free( &map->models[i].mdl );
+ }
+
+ vdf_free_r( map->root );
+ csr_sb_free( map->models );
+ csr_sb_free( map->cache );
+ free( map );
+}
+
void solidgen_to_obj( vmf_solid *ctx, const char *path )
{
FILE *fp = fopen( path, "w" );
projects / csRadar.git / commitdiff