csRadar.c

   1 #include <stdint.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include <math.h>
   6 #include <time.h>
   7
   8 // CSR lib
   9 #include "csrTypes.h"
  10 #include "csrMath.h"
  11 #include "csrMem.h"
  12 #include "csrIO.h"
  13 #include "csrComb.h"
  14
  15 // Valve formats
  16 #include "vdf.h"
  17 #include "vpk.h"
  18 #include "vfilesys.h"
  19
  20 #include "vmdl.h"
  21 #include "vmf.h"
  22
  23 // CSR main
  24 #include "csrDraw.h"
  25 #include "csr32f.h"
  26
  27
  28 //#include "stretchy_buffer.h"
  29
  30 int main( int argc, char *argv[] )
  31 {
  32         if( argc == 2 )
  33         {
  34                 fs_set_gameinfo( "/home/harry/SteamLibrary/steamapps/common/Counter-Strike Global Offensive/csgo/gameinfo.txt" );
  35
  36                 printf( "read: %s\n", argv[1] );
  37                 //vdf_node *node = vdf_open_file( argv[1] );
  38
  39                 vmf_map *map = vmf_init( argv[1], 1 );
  40
  41                 csr_target target;
  42
  43                 csr_create_target( &target, 1024, 1024 );
  44                 csr_rt_clear( &target );
  45
  46                 csr_filter filter_layout =
  47                 {
  48                         .classname = NULL,
  49                         .visgroup = "tar_layout"
  50                 };
  51
  52                 csr_filter filter_buyzone =
  53                 {
  54                         .classname = "func_buyzone",
  55                         .visgroup = NULL
  56                 };
  57
  58                 csr_filter filter_setup =
  59                 {
  60                         .classname = NULL,
  61                         .visgroup = NULL,
  62                         .compute_bounds_only = 1
  63                 };
  64
  65                 draw_vmf_group( &target, map, map->root, &filter_setup, NULL, NULL );
  66                 csr_auto_fit( &target, 128.f );
  67
  68                 draw_vmf_group( &target, map, map->root, NULL, NULL, NULL );
  69
  70                 float *rgba_test = (float *)csr_malloc( 1024*1024*sizeof(float)*3 );
  71
  72                 for( int l = 0; l < 1024; l ++ )
  73                 {
  74                         for( int x = 0; x < 1024; x ++ )
  75                         {
  76                                 float *dst = &rgba_test[ (l*1024+x)*3 ];
  77                                 csr_frag *src = &target.fragments[ ((1023-l)*1024+x) ];
  78
  79                                 dst[0] = src->co[0];
  80                                 dst[1] = src->co[1];
  81                                 dst[2] = src->co[2];
  82                         }
  83                 }
  84
  85                 csr_32f_write( "hello.pfm", 1024, 1024, rgba_test );
  86
  87                 csr_rt_free( &target );
  88
  89                 free( rgba_test );
  90                 vmf_free( map );
  91                 fs_exit();
  92
  93                 /*
  94                 vmf_solid solid_main;
  95
  96
  97                 solidgen_ctx_init( &solid_main );
  98
  99                 vdf_node *world = vdf_next( node, "world", NULL );
 100
 101                 vdf_foreach( world, "solid", brush )
 102                 {
 103                         solidgen_push( &solid_main, brush );
 104                 }
 105
 106                 clock_t t;
 107                 t = clock();
 108                 printf("Timer starts\n");
 109
 110                 csr_frag *image = (csr_frag *)csr_malloc( 1024*1024*sizeof(csr_frag) );
 111                 clear_depth( image, 1024, 1024 );
 112
 113                 for( int i = 0; i < csr_sb_count( solid_main.indices )/3; i ++ )
 114                 {
 115                         u32 * base = solid_main.indices + i*3;
 116
 117                         vmf_vert tri[3];
 118
 119                         tri[0] = solid_main.verts[ base[0] ];
 120                         tri[1] = solid_main.verts[ base[1] ];
 121                         tri[2] = solid_main.verts[ base[2] ];
 122
 123                         draw_buffers( image, 1024, 1024, (v4f){ -1000.f, -1000.f, 1000.f, 1000.f }, tri, 1 );
 124                 }
 125
 126                 printf("Timer ends \n");
 127                 t = clock() - t;
 128                 double time_taken = ((double)t)/CLOCKS_PER_SEC; // calculate the elapsed time
 129                 printf("Tracing took %f seconds to execute\n", time_taken);
 130
 131                 float *rgba_test = (float *)csr_malloc( 1024*1024*sizeof(float)*3 );
 132
 133                 for( int i = 0; i < 1024*1024; i ++ )
 134                 {
 135                         rgba_test[i*3+0] = image[i].qa;
 136                         rgba_test[i*3+1] = image[i].qb;
 137                         rgba_test[i*3+2] = image[i].depth;
 138                 }
 139
 140                 csr_32f_write( "hello.pfm", 1024, 1024, rgba_test );
 141
 142                 free( rgba_test );
 143                 free( image );
 144
 145                 solidgen_to_obj( &solid_main, "hello.obj" );
 146
 147                 vdf_free_r( node );
 148                 */
 149         }
 150 }