fixed instance loading forget to append basepath.. other path fixes (windows)

[csRadar.git] / vmf.h

diff --git a/vmf.h b/vmf.h
index d2bbbd214dd21b85c74a2edf2f429481f28a67d1..740a3749da0af94070dabd7da5077aaae7ac8197 100644 (file)
--- a/vmf.h
+++ b/vmf.h
@@ -1,7 +1,8 @@
-#define SOLID_MAX_SIDES 512
-#define VMF_FLAG_IS_PROP 0x1
-#define VMF_FLAG_IS_INSTANCE 0x2
-#define VMF_FLAG_BRUSH_ENT 0x4
+// This software is not affiliated with Valve Corporation
+//   We are not affiliated, associated, authorized, endorsed by, or in any way officially 
+//   connected with Valve Corporation, or any of its subsidiaries or its affiliates. 
+// 
+//   All trademarks are property of their respective owners

 
 typedef struct vmf_solid vmf_solid;
 typedef struct vmf_vert vmf_vert;
 
 typedef struct vmf_solid vmf_solid;
 typedef struct vmf_vert vmf_vert;


@@ -12,6 +13,53 @@ typedef struct vmf_map vmf_map;
 
 typedef enum ESolidResult ESolidResult;
 
 
 typedef enum ESolidResult ESolidResult;
 

+// API
+//=======================================================================================================================
+
+// Load vmf from disk
+vmf_map *vmf_init( const char *path );
+void vmf_free( vmf_map *map );
+
+// Solidgen API ~ Converting brushes into meshes
+// ---------------------------------------------
+void solidgen_ctx_init( vmf_solid *ctx );
+void solidgen_ctx_reset( vmf_solid *ctx );
+void solidgen_ctx_free( vmf_solid *ctx );
+void solidgen_bounds( vmf_solid *ctx, boxf box );
+
+ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node );
+
+// General VMF
+// -----------
+int solid_has_displacement( vdf_node *node );
+int vmf_class_is_prop( vdf_node *ent );
+
+// Build the list of all models used in this map, including instances
+void vmf_index_models( vmf_map *map );
+
+// Loads all models that have the resource flagged with need_load
+void vmf_load_models( vmf_map *map );
+
+// Create matrix describing this entities transform
+void vmf_entity_transform( vdf_node *ent, m4x3f mat );
+
+int vmf_visgroup_id( vdf_node *root, const char *name );
+int vmf_visgroup_match( vdf_node *ent, u32 target );
+
+// Currently unused
+//void vmf_addbisector( double p[4] );
+//void vmf_clearbisectors( void );
+//void vmf_ignore_mat( const char *material );
+//void vmf_clearignore( void );
+
+// Implementation
+//=======================================================================================================================
+
+#define SOLID_MAX_SIDES 512
+#define VMF_FLAG_IS_PROP 0x1
+#define VMF_FLAG_IS_INSTANCE 0x2
+#define VMF_FLAG_BRUSH_ENT 0x4
+

 enum ESolidResult
 {
        k_ESolidResult_valid,
 enum ESolidResult
 {
        k_ESolidResult_valid,


@@ -26,7 +74,7 @@ struct vmf_vert
 {
        v3f     co;
        v3f     nrm;
 {
        v3f     co;
        v3f     nrm;

-       v2f     xy;
+       v3f     origin;

 };
 
 struct vmf_face
 };
 
 struct vmf_face


@@ -61,6 +109,8 @@ struct vmf_map
                u32     hash;
                
                mdl_mesh_t mdl;
                u32     hash;
                
                mdl_mesh_t mdl;

+               
+               int need_load;

        }
        *models;
        
        }
        *models;
        


@@ -78,7 +128,7 @@ struct vmf_map
        m4x3f transform;
 };
 
        m4x3f transform;
 };
 

-// IMPLEMENTATION
+#ifdef VALVE_IMPLEMENTATION

 
 void solidgen_ctx_reset( vmf_solid *ctx )
 {
 
 void solidgen_ctx_reset( vmf_solid *ctx )
 {


@@ -280,30 +330,12 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
 {
        ESolidResult flag = k_ESolidResult_valid;
 
 {
        ESolidResult flag = k_ESolidResult_valid;
 

+       double planes[ SOLID_MAX_SIDES*4 ];

        vmf_face faces[ SOLID_MAX_SIDES ];
 
        vmf_face faces[ SOLID_MAX_SIDES ];
 

-       int is_displacement = 0;
+       int is_displacement = solid_has_displacement( node );

        int num_planes = 0;
        
        int num_planes = 0;
        

-       // TODO: What is this for again? surely it should be the other way around... i think...
-       if( solid_has_displacement( node ) )
-       {
-               printf( "solid_has_displacement\n" );
-               num_planes = vmf_api.bisectors;
-       
-               // Add dummy stuff for globals
-               // ???
-               for( int k = 0; k < vmf_api.bisectors; k ++ )
-               {
-                       vmf_face *dummy = faces + k;
-                       dummy->indices = NULL;
-                       dummy->dispinfo = NULL;
-                       dummy->material = NULL;
-               }
-               
-               is_displacement = 1;
-       }
-       

        int it = 0; 
        vdf_node *pSide;
        while( (pSide = vdf_next(node, "side", &it)) )
        int it = 0; 
        vdf_node *pSide;
        while( (pSide = vdf_next(node, "side", &it)) )


@@ -311,7 +343,7 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                if( num_planes >= SOLID_MAX_SIDES )
                {
                        flag = k_ESolidResult_maxsides;
                if( num_planes >= SOLID_MAX_SIDES )
                {
                        flag = k_ESolidResult_maxsides;

-                       fprintf( stderr, "Solid over maxsides limit (%i)\n", SOLID_MAX_SIDES );
+                       log_error( "Solid over maxsides limit (%i)\n", SOLID_MAX_SIDES );

                        break;
                }
        
                        break;
                }
        


@@ -325,7 +357,7 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                
                kv_double_array( pSide, "plane", 9, points );
                
                
                kv_double_array( pSide, "plane", 9, points );
                

-               tri_to_plane( points+6, points+3, points+0, vmf_api.planes + num_planes * 4 );
+               tri_to_plane( points+6, points+3, points+0, planes + num_planes * 4 );

                num_planes ++;
        }
        
                num_planes ++;
        }
        


@@ -345,14 +377,14 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                if( (faces[ i[0] ].blacklisted && faces[ i[1] ].blacklisted && faces[ i[2] ].blacklisted) )
                        continue;
                        
                if( (faces[ i[0] ].blacklisted && faces[ i[1] ].blacklisted && faces[ i[2] ].blacklisted) )
                        continue;
                        

-               if( !plane_intersect( vmf_api.planes+i[0]*4, vmf_api.planes+i[1]*4, vmf_api.planes+i[2]*4, p ) )
+               if( !plane_intersect( planes+i[0]*4, planes+i[1]*4, planes+i[2]*4, p ) )

                        continue;
 
                // Check for illegal verts (eg: got clipped by bisectors)
                int valid = 1;
                for( int m = 0; m < num_planes; m ++ )
                {
                        continue;
 
                // Check for illegal verts (eg: got clipped by bisectors)
                int valid = 1;
                for( int m = 0; m < num_planes; m ++ )
                {

-                       if( plane_polarity( vmf_api.planes+m*4, p ) > 1e-6f )
+                       if( plane_polarity( planes+m*4, p ) > 1e-6f )

                        {
                                valid = 0;
                                break;
                        {
                                valid = 0;
                                break;


@@ -377,7 +409,7 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                                        face_add_indice( faces + i[k], c );
                                        
                                        v3d_v3f( p, ctx->verts[ c ].co );
                                        face_add_indice( faces + i[k], c );
                                        
                                        v3d_v3f( p, ctx->verts[ c ].co );

-                                       v3d_v3f( vmf_api.planes+i[k]*4, ctx->verts[ c ].nrm );
+                                       v3d_v3f( planes+i[k]*4, ctx->verts[ c ].nrm );

                                        
                                        csr_sb_inc( ctx->verts, 1 );
                                }
                                        
                                        csr_sb_inc( ctx->verts, 1 );
                                }


@@ -390,11 +422,11 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
        v3_divs( center, (float)numpoints, center );
        for( ; vert_start < csr_sb_count( ctx->verts ); vert_start ++ )
        {
        v3_divs( center, (float)numpoints, center );
        for( ; vert_start < csr_sb_count( ctx->verts ); vert_start ++ )
        {

-               v2_copy( center, ctx->verts[ vert_start ].xy );
+               v3_copy( center, ctx->verts[ vert_start ].origin );

        }
        
        // Sort each faces and trianglulalate them
        }
        
        // Sort each faces and trianglulalate them

-       for( int k = vmf_api.bisectors; k < num_planes; k ++ )
+       for( int k = 0; k < num_planes; k ++ )

        {
                vmf_face *face = faces + k;
        
        {
                vmf_face *face = faces + k;
        


@@ -402,18 +434,15 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
 
                if( csr_sb_count( face->indices ) < 3 )
                {
 
                if( csr_sb_count( face->indices ) < 3 )
                {

-                       if( !vmf_api.bisectors )
-                       {
-                               flag = k_ESolidResult_degenerate;
-                               fprintf( stderr, "Skipping degenerate face\n" );
-                       }
+                       flag = k_ESolidResult_degenerate;
+                       log_error( "Skipping degenerate face\n" );

                        continue;
                }
                
                // Sort only if there is no displacements, or if this side is
                if( !is_displacement || ( is_displacement && face->dispinfo ) )
                {
                        continue;
                }
                
                // Sort only if there is no displacements, or if this side is
                if( !is_displacement || ( is_displacement && face->dispinfo ) )
                {

-                       sort_coplanar( vmf_api.planes+k*4, ctx->verts, face->indices, csr_sb_count( face->indices ) );
+                       sort_coplanar( planes+k*4, ctx->verts, face->indices, csr_sb_count( face->indices ) );

                }
                
                if( is_displacement )
                }
                
                if( is_displacement )


@@ -423,13 +452,8 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                        {
                                if( csr_sb_count( face->indices ) != 4 )
                                {
                        {
                                if( csr_sb_count( face->indices ) != 4 )
                                {

-                                       // Mute error if we have global planes cause they
-                                       // are of course gonna fuck things up here
-                                       if( !vmf_api.bisectors )
-                                       {
-                                               flag = k_ESolidResult_degenerate;
-                                               fprintf( stderr, "Skipping degenerate displacement\n" );
-                                       }
+                                       flag = k_ESolidResult_degenerate;
+                                       log_error( "Skipping degenerate displacement\n" );

                                        continue;
                                }
                        
                                        continue;
                                }
                        


@@ -454,12 +478,6 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                                        }
                                }
                                
                                        }
                                }
                                

-                               // Get corners of displacement
-                               float *SW = ctx->verts[ face->indices[ sw ] ].co;
-                               float *NW = ctx->verts[ face->indices[ (sw+1) % 4] ].co;
-                               float *NE = ctx->verts[ face->indices[ (sw+2) % 4] ].co;
-                               float *SE = ctx->verts[ face->indices[ (sw+3) % 4] ].co;
-                               

                                // Can be either 5, 9, 17
                                numpoints = pow( 2, kv_get_int( dispinfo, "power", 2 ) ) + 1;
                                u32 reqverts = numpoints*numpoints;
                                // Can be either 5, 9, 17
                                numpoints = pow( 2, kv_get_int( dispinfo, "power", 2 ) ) + 1;
                                u32 reqverts = numpoints*numpoints;


@@ -467,6 +485,12 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                                
                                ctx->verts = csr_sb_reserve( ctx->verts, reqverts, sizeof( vmf_vert ) );
                                ctx->indices = csr_sb_reserve( ctx->indices, reqidx, sizeof( u32 ) );
                                
                                ctx->verts = csr_sb_reserve( ctx->verts, reqverts, sizeof( vmf_vert ) );
                                ctx->indices = csr_sb_reserve( ctx->indices, reqidx, sizeof( u32 ) );

+
+                               // Get corners of displacement
+                               float *SW = ctx->verts[ face->indices[ sw ] ].co;
+                               float *NW = ctx->verts[ face->indices[ (sw+1) % 4] ].co;
+                               float *NE = ctx->verts[ face->indices[ (sw+2) % 4] ].co;
+                               float *SE = ctx->verts[ face->indices[ (sw+3) % 4] ].co;

                                
                                float normals[ 17*3 ];
                                float distances[ 17 ];
                                
                                float normals[ 17*3 ];
                                float distances[ 17 ];


@@ -498,6 +522,9 @@ ESolidResult solidgen_push( vmf_solid *ctx, vdf_node *node )
                                                
                                                // Todo, put correct normal
                                                v3_copy( (v3f){ 0.f, 0.f, 1.f }, vert->nrm );
                                                
                                                // Todo, put correct normal
                                                v3_copy( (v3f){ 0.f, 0.f, 1.f }, vert->nrm );

+                                               
+                                               // Todo: use real bounds of displaced vertices
+                                               v3_copy( center, vert->origin );

                                        }
                                }
                                
                                        }
                                }
                                


@@ -598,6 +625,9 @@ void vmf_populate_models( vdf_node *vmf, vmf_map *map )
                                map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
                                
                                struct vmf_model *entry = &map->models[ csr_sb_count( map->models ) ];
                                map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
                                
                                struct vmf_model *entry = &map->models[ csr_sb_count( map->models ) ];

+                               entry->need_load = 0;
+                               mdl_error( &entry->mdl );       // (just setting arrays to 0)
+                               

                                entry->str = csr_malloc( strlen( model_path ) +1 );
                                strcpy( entry->str, model_path );
                                entry->hash = djb2( (const unsigned char *)model_path );
                                entry->str = csr_malloc( strlen( model_path ) +1 );
                                strcpy( entry->str, model_path );
                                entry->hash = djb2( (const unsigned char *)model_path );


@@ -614,11 +644,11 @@ void vmf_populate_models( vdf_node *vmf, vmf_map *map )
 }
 
 // Load all models
 }
 
 // Load all models

-void vmf_load_models( vmf_map *map )
+void vmf_index_models( vmf_map *map )

 {
 {

-       printf( "Loading all models\n" );
+       log_info( "Indexing all models\n" );

        
        

-       // Error model. TODO: Maybe don't have this be junk data.
+       // Error model == blank

        map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
        csr_sb_use( map->models );
        mdl_error( &map->models[0].mdl );
        map->models = csr_sb_reserve( map->models, 1, sizeof( struct vmf_model ));
        csr_sb_use( map->models );
        mdl_error( &map->models[0].mdl );


@@ -631,42 +661,58 @@ void vmf_load_models( vmf_map *map )
                vmf_populate_models( map->cache[i].root, map );
        }
        
                vmf_populate_models( map->cache[i].root, map );
        }
        

-       printf( "Indexed (%u) models\n", csr_sb_count( map->models )-1 );
-       
+       log_info( "Indexed (%u) models\n", csr_sb_count( map->models )-1 );
+}
+
+void vmf_load_models( vmf_map *map )
+{

        u32 num_success = 0;
        u32 num_success = 0;

+       u32 num_reqs = 0;

        
        

-       // Load model data
-       // TODO: Make nice loading bar

        for( int i = 1; i < csr_sb_count( map->models ); i ++ )
        {
                struct vmf_model *mdl = &map->models[i];
                
        for( int i = 1; i < csr_sb_count( map->models ); i ++ )
        {
                struct vmf_model *mdl = &map->models[i];
                

-               if( mdl_from_find_files( mdl->str, &mdl->mdl ) )
+               if( mdl->need_load )

                {
                {

-                       num_success ++;
-               }
-               else
-               {
-                       fprintf( stderr, "Failed to load model: %s\n", mdl->str );
+                       num_reqs ++;
+               
+                       if( mdl_from_find_files( mdl->str, &mdl->mdl ) )
+                       {
+                               num_success ++;
+                       }
+                       else
+                       {
+                               log_warn( "Failed to load model: %s\n", mdl->str );
+                       }

                }
        }
        
                }
        }
        

-       printf( "Done (%u of %u loaded)\n", num_success, csr_sb_count( map->models )-1 );
+       log_info( "Done (%u of %u loaded)\n", num_success, num_reqs );

 }
 
 u32 vmf_init_subvmf( vmf_map *map, const char *subvmf );
 
 void vmf_load_all_instances( vmf_map *map, vdf_node *vmf )
 {
 }
 
 u32 vmf_init_subvmf( vmf_map *map, const char *subvmf );
 
 void vmf_load_all_instances( vmf_map *map, vdf_node *vmf )
 {

+       char nextvmf[ 512 ];
+       const char *base = kv_get( vmf, "csr_path", "" );
+

        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.
        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, "" ) )
+                       const char *path = kv_get( ent, "file", NULL );
+                       
+                       if( path )

                        {
                        {

-                               if( (ent->user1 = vmf_init_subvmf( map, path )))
+                               // Make relative path real
+                               strcpy( nextvmf, base );
+                               csr_downlvl( nextvmf );
+                               strcat( nextvmf, path );
+                               
+                               if( (ent->user1 = vmf_init_subvmf( map, nextvmf )))

                                {
                                        ent->user1 --;
                                        ent->user = VMF_FLAG_IS_INSTANCE;
                                {
                                        ent->user1 --;
                                        ent->user = VMF_FLAG_IS_INSTANCE;


@@ -689,51 +735,56 @@ u32 vmf_init_subvmf( vmf_map *map, const char *subvmf )
                {
                        if( !strcmp( map->cache[i].name, subvmf ) )
                        {
                {
                        if( !strcmp( map->cache[i].name, subvmf ) )
                        {

-                               return i+1;
+                               if( map->cache[i].root )
+                                       return i+1;
+                               else
+                                       return 0;

                        }
                }
        }
        
                        }
                }
        }
        

-       printf( "Loading subvmf: %s\n", subvmf );
-       

        id = csr_sb_count( map->cache );
        map->cache = csr_sb_reserve( map->cache, 1, sizeof( struct vmf_instance ));
        struct vmf_instance *inst = &map->cache[ id ];
        
        id = csr_sb_count( map->cache );
        map->cache = csr_sb_reserve( map->cache, 1, sizeof( struct vmf_instance ));
        struct vmf_instance *inst = &map->cache[ id ];
        

+       csr_sb_use( map->cache );
+       inst->hash = hash;
+       inst->name = csr_malloc( strlen( subvmf )+1 );
+       strcpy( inst->name, subvmf );
+       

        if( (inst->root = vdf_open_file( subvmf )) )
        {
        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 );
+               vdf_kv_append( inst->root, "csr_path", subvmf );

                
                // Recursive load other instances
                
                // Recursive load other instances

-               vmf_load_all_instances( map, inst->root );
-               
+               vmf_load_all_instances( map, inst->root );      

                return id+1;
        }
        else
        {
                return id+1;
        }
        else
        {

-               fprintf( stderr, "Failed to load instance file\n" );
+               log_error( "Failed to load instance file: %s\n", subvmf );

                return 0;
        }
 }
 
                return 0;
        }
 }
 

-vmf_map *vmf_init( const char *path, int load_models )
+vmf_map *vmf_init( const char *path )

 {
        vmf_map *map = csr_calloc( sizeof( vmf_map ) );
        map->root = vdf_open_file( path );
        
 {
        vmf_map *map = csr_calloc( sizeof( vmf_map ) );
        map->root = vdf_open_file( path );
        

+       if( !map->root )
+       {
+               free( map );
+               return NULL;
+       }
+       
+       vdf_kv_append( map->root, "csr_path", path );
+       

        // Prepare instances
        vmf_load_all_instances( map, map->root );
        
        // Other resources
        // Prepare instances
        vmf_load_all_instances( map, map->root );
        
        // Other resources

-       if( load_models )
-       {
-               vmf_load_models( map );
-       }
-       
+       vmf_index_models( map );        

        return map;
 }
 
        return map;
 }
 


@@ -741,7 +792,9 @@ void vmf_free( vmf_map *map )
 {
        for( int i = 0; i < csr_sb_count( map->cache ); i ++ )
        {
 {
        for( int i = 0; i < csr_sb_count( map->cache ); i ++ )
        {

-               vdf_free_r( map->cache[i].root );
+               if( map->cache[i].root )
+                       vdf_free_r( map->cache[i].root );
+       

                free( map->cache[i].name );
        }
        
                free( map->cache[i].name );
        }
        


@@ -757,51 +810,6 @@ void vmf_free( vmf_map *map )
        free( map );
 }
 
        free( map );
 }
 

-void solidgen_to_obj( vmf_solid *ctx, const char *path )
-{
-       FILE *fp = fopen( path, "w" );
-
-       if( fp )
-       {
-               fprintf( fp, "o vmf_export\n" );
-       
-               vmf_vert *vert;
-       
-               // Write vertex block
-               for( int i = 0; i < csr_sb_count( ctx->verts ); i ++ )
-               {
-                       vert = &ctx->verts[i];
-                       fprintf( fp, "v %f %f %f\n", vert->co[0], vert->co[1], vert->co[2] );
-               }
-               
-               // Write normals block
-               for( int i = 0; i < csr_sb_count( ctx->verts ); i ++ )
-               {
-                       vert = &ctx->verts[i];
-                       fprintf( fp, "vn %f %f %f\n", vert->nrm[0], vert->nrm[1], vert->nrm[2] );
-               }
-               
-               fprintf( fp, "s off\n" );
-               
-               // Indices
-               for( int i = 0; i < csr_sb_count( ctx->indices )/3; i ++ )
-               {
-                       u32 * base = ctx->indices + i*3;
-                       fprintf( fp, "f %u//%u %u//%u %u//%u\n", 
-                               base[2]+1, base[2]+1, 
-                               base[1]+1, base[1]+1, 
-                               base[0]+1, base[0]+1 
-                       );
-               }
-       
-               fclose( fp );
-       }
-       else
-       {
-               fprintf( stderr, "Could not open %s for writing\n", path );
-       }
-}
-

 void vmf_entity_transform( vdf_node *ent, m4x3f mat )
 {
        v3f angles = {0.f,0.f,0.f};
 void vmf_entity_transform( vdf_node *ent, m4x3f mat )
 {
        v3f angles = {0.f,0.f,0.f};


@@ -825,7 +833,7 @@ void vmf_entity_transform( vdf_node *ent, m4x3f mat )
        m4x3_scale( mat, scale );
 }
 
        m4x3_scale( mat, scale );
 }
 

-u32 vmf_visgroup_id( vdf_node *root, const char *name )
+int vmf_visgroup_id( vdf_node *root, const char *name )

 {
        vdf_node *dict = vdf_next( root, "visgroups", NULL );
        
 {
        vdf_node *dict = vdf_next( root, "visgroups", NULL );
        


@@ -840,7 +848,7 @@ u32 vmf_visgroup_id( vdf_node *root, const char *name )
                }
        }
        
                }
        }
        

-       return 0;
+       return -1;

 }
 
 int vmf_visgroup_match( vdf_node *ent, u32 target )
 }
 
 int vmf_visgroup_match( vdf_node *ent, u32 target )


@@ -858,3 +866,5 @@ int vmf_visgroup_match( vdf_node *ent, u32 target )
        
        return 0;
 }
        
        return 0;
 }

+
+#endif