int main(int argc, char** argv) { if (argc < 2 || argc > 3) { printf( "USAGE: URDFtoRob robot_file.urdf [optional filename for .rob]\n"); return 0; } string filename; const char* fname; if(argc == 2) filename.assign(argv[1]); else if(argc == 3) filename.assign(argv[2]); StripExtension(filename); filename.append(".rob"); const char* ext = FileExtension(argv[1]); string path = GetFilePath(argv[1]); if (0 == strcmp(ext, "urdf")) { Robot robot; robot.LoadURDF(argv[1]); robot.Save(filename.c_str(), path.c_str()); robot.SaveGeometry(path.c_str(),"tri"); } else { printf("Unknown file extension %s on file %s!\nOnly converts URDF to Rob", ext, argv[1]); return 1; } cout<<"Converted "<<argv[1]<<" to "<< filename<<endl; cout << "Done!" << endl; }
image_t *ImageFind( const char *filename ) { int i; char name[ 1024 ]; /* init */ ImageInit(); /* dummy check */ if( filename == NULL || filename[ 0 ] == '\0' ) return NULL; /* strip file extension off name */ strcpy( name, filename ); StripExtension( name ); /* search list */ for( i = 0; i < MAX_IMAGES; i++ ) { if( images[ i ].name != NULL && !strcmp( name, images[ i ].name ) ) return &images[ i ]; } /* no matching image found */ return NULL; }
/* * @brief */ s_sample_t *S_LoadSample(const char *name) { char key[MAX_QPATH]; s_sample_t *sample; if (!s_env.initialized) return NULL; if (!name || !name[0]) { Com_Error(ERR_DROP, "NULL name\n"); } StripExtension(name, key); if (!(sample = (s_sample_t *) S_FindMedia(key))) { sample = (s_sample_t *) S_AllocMedia(key, sizeof(s_sample_t)); sample->media.Free = S_FreeSample; S_LoadSampleChunk(sample); S_RegisterMedia((s_media_t *) sample); } return sample; }
void MakeLITFile (const char *filename) { char litname[1024]; FILE *litfile; litheader_t litheader; strcpy (litname, filename); StripExtension (litname); DefaultExtension (litname, ".lit", sizeof(litname)); litfile = fopen (litname, "wb"); if (!litfile) { printf ("Unable to create %s\n", litname); return; } litheader.ident[0] = 'Q'; litheader.ident[1] = 'L'; litheader.ident[2] = 'I'; litheader.ident[3] = 'T'; litheader.version = LittleLong(LIT_VERSION); fwrite (&litheader, sizeof(litheader), 1, litfile); fwrite (&newdlightdata, newlightdatasize, 1, litfile); fclose (litfile); printf ("Wrote litfile: %s\n", litname); }
void be_root::Generate (be_ClientImplementation & source) { ostream & os = source.Stream (); TList<be_CodeGenerator*>::iterator iit; TList<be_Type*>::iterator bit; for (iit = implementations.begin(); iit != implementations.end(); iit++) { (*iit)->Generate(source); } os << nl; be_CodeGenerator::Generate (source); os << nl; if (BE_Globals::lite) { DDS_StdString BaseFilename; BaseFilename = StripExtension(source.Filename()); os << "#include \"" << BaseFilename << "-lite.c" << "\"" << nl; } os << nl; source.Close(); }
int CBlockStream::Create( char *filename ) { char newName[MAX_FILENAME_LENGTH], *id_header = IBI_HEADER_ID; float version = IBI_VERSION; //Clear the temp string memset(newName, 0, sizeof(newName)); //Strip the extension and add the BLOCK_EXT extension strcpy((char *) m_fileName, filename); StripExtension( (char *) m_fileName, (char *) &newName ); strcat((char *) newName, IBI_EXT); //Recover that as the active filename strcpy(m_fileName, newName); if ( (m_fileHandle = fopen(m_fileName, "wb")) == NULL ) { return false; } fwrite( id_header, IBI_HEADER_ID_LENGTH, 1, m_fileHandle ); fwrite( &version, sizeof(version), 1, m_fileHandle ); return true; }
void Pointfile_Delete( void ) { char name[1024]; strcpy( name, currentmap ); StripExtension( name ); strcat( name, ".lin" ); remove( name ); }
/* * @brief */ void WriteAASFile(void) { char path[MAX_QPATH]; file_t *f; StripExtension(bsp_name, path); g_strlcat(path, ".aas", sizeof(path)); if (!(f = Fs_OpenWrite(path))) { Com_Error(ERR_FATAL, "Couldn't open %s for writing\n", path); } Com_Print("Writing %d AAS nodes..\n", d_aas.num_nodes); SwapAASFile(); d_bsp_header_t header; memset(&header, 0, sizeof(header)); header.ident = LittleLong(AAS_IDENT); header.version = LittleLong(AAS_VERSION); Fs_Write(f, &header, 1, sizeof(header)); d_bsp_lump_t *lump = &header.lumps[AAS_LUMP_NODES]; WriteLump(f, lump, d_aas.nodes, sizeof(d_aas_node_t) * d_aas.num_nodes); // rewrite the header with the populated lumps Fs_Seek(f, 0); Fs_Write(f, &header, 1, sizeof(header)); Fs_Close(f); }
/* * @brief Loads the music by the specified name. */ s_music_t *S_LoadMusic(const char *name) { char key[MAX_QPATH]; s_music_t *music; StripExtension(name, key); if (!(music = (s_music_t *) S_FindMedia(key))) { void *buffer; SDL_RWops *rw; Mix_Music *mus; if (S_LoadMusicFile(key, &buffer, &rw, &mus)) { music = (s_music_t *) S_AllocMedia(key, sizeof(s_music_t)); music->media.Retain = S_RetainMusic; music->media.Free = S_FreeMusic; music->buffer = buffer; music->rw = rw; music->music = mus; S_RegisterMedia((s_media_t *) music); } else { Com_Debug("S_LoadMusic: Couldn't load %s\n", key); music = NULL; } } if (music) { s_music_state.playlist = g_list_append(s_music_state.playlist, music); } return music; }
/** * @brief Handles the actual loading of .ogg music files. */ static _Bool S_LoadMusicFile(const char *name, void **buffer, SDL_RWops **rw, Mix_Music **music) { char path[MAX_QPATH]; *music = NULL; StripExtension(name, path); g_snprintf(path, sizeof(path), "music/%s.ogg", name); int64_t len; if ((len = Fs_Load(path, buffer)) != -1) { if ((*rw = SDL_RWFromMem(*buffer, (int32_t) len))) { if ((*music = Mix_LoadMUS_RW(*rw, false))) { Com_Debug(DEBUG_SOUND, "Loaded %s\n", name); } else { Com_Warn("Failed to load %s: %s\n", name, Mix_GetError()); SDL_FreeRW(*rw); } } else { Com_Warn("Failed to create SDL_RWops for %s\n", name); Fs_Free(*buffer); } } else { Com_Debug(DEBUG_SOUND, "Failed to load %s\n", name); } return *music != NULL; }
void ExportEntities( void ){ char filename[ 1024 ]; FILE *file; /* note it */ Sys_FPrintf( SYS_VRB, "--- ExportEntities ---\n" ); /* do some path mangling */ strcpy( filename, source ); StripExtension( filename ); strcat( filename, ".ent" ); /* sanity check */ if ( bspEntData == NULL || bspEntDataSize == 0 ) { Sys_Warning( "No BSP entity data. aborting...\n" ); return; } /* write it */ Sys_Printf( "Writing %s\n", filename ); Sys_FPrintf( SYS_VRB, "(%d bytes)\n", bspEntDataSize ); file = fopen( filename, "w" ); if ( file == NULL ) { Error( "Unable to open %s for writing", filename ); } fprintf( file, "%s\n", bspEntData ); fclose( file ); }
void RadCreateDiffuseLights( void ){ /* startup */ Sys_FPrintf( SYS_VRB, "--- RadCreateDiffuseLights ---\n" ); numDiffuseSurfaces = 0; numDiffuseLights = 0; numBrushDiffuseLights = 0; numTriangleDiffuseLights = 0; numPatchDiffuseLights = 0; numAreaLights = 0; /* hit every surface (threaded) */ RunThreadsOnIndividual( numBSPDrawSurfaces, qtrue, RadLight ); /* dump the lights generated to a file */ if ( dump ) { char dumpName[ 1024 ], ext[ 64 ]; FILE *file; light_t *light; strcpy( dumpName, source ); StripExtension( dumpName ); sprintf( ext, "_bounce_%03d.map", iterations ); strcat( dumpName, ext ); file = fopen( dumpName, "wb" ); Sys_Printf( "Writing %s...\n", dumpName ); if ( file ) { for ( light = lights; light; light = light->next ) { fprintf( file, "{\n" "\"classname\" \"light\"\n" "\"light\" \"%d\"\n" "\"origin\" \"%.0f %.0f %.0f\"\n" "\"_color\" \"%.3f %.3f %.3f\"\n" "}\n", (int) light->add, light->origin[ 0 ], light->origin[ 1 ], light->origin[ 2 ], light->color[ 0 ], light->color[ 1 ], light->color[ 2 ] ); } fclose( file ); } } /* increment */ iterations++; /* print counts */ Sys_Printf( "%8d diffuse surfaces\n", numDiffuseSurfaces ); Sys_FPrintf( SYS_VRB, "%8d total diffuse lights\n", numDiffuseLights ); Sys_FPrintf( SYS_VRB, "%8d brush diffuse lights\n", numBrushDiffuseLights ); Sys_FPrintf( SYS_VRB, "%8d patch diffuse lights\n", numPatchDiffuseLights ); Sys_FPrintf( SYS_VRB, "%8d triangle diffuse lights\n", numTriangleDiffuseLights ); }
void MakeAllScales (void) { strcpy(transferfile, source); StripExtension( transferfile ); DefaultExtension( transferfile, ".r2" ); if ( !incremental || !IsIncremental(incrementfile) || (unsigned)readtransfers(transferfile, num_patches) != num_patches ) { // determine visibility between patches BuildVisMatrix (); RunThreadsOn (num_patches, true, MakeScales); if ( incremental ) writetransfers(transferfile, num_patches); else unlink(transferfile); // release visibility matrix FreeVisMatrix (); } qprintf ("transfer lists: %5.1f megs\n" , (float)total_transfer * sizeof(transfer_t) / (1024*1024)); }
/** * @brief */ static cm_material_t *Cm_LoadBspMaterials(const char *name) { char base[MAX_QPATH]; StripExtension(Basename(name), base); return Cm_LoadMaterials(va("materials/%s.mat", base), NULL); }
/** Helper function to find and kill the specified process */ TInt CGsaFlexiMergeManyFilesTest::FindAndKill(const TDesC& aProcessName) { TFullName searchTerm(aProcessName); StripExtension(searchTerm); searchTerm += _L("*"); TFindProcess find(searchTerm); TFullName name; TInt instancesFound = 0; while(find.Next(name) == KErrNone) { RProcess process; const TInt err = process.Open(find); if (KErrNone == err) { if (process.ExitType() == EExitPending) { instancesFound++; process.Kill(KErrCancel); process.Close(); INFO_PRINTF2(_L("Process %S found and killed"), &aProcessName); } process.Close(); } } return instancesFound; }
// package creation tool main function ---------------------------------------- // void MAKEPACK_main( int argc, char **argv ) { // clear options of main app OPT_ClearOptions(); // register local options OPT_RegisterStringOption( "p", "pack", Tm_SetPackageName ); OPT_RegisterStringOption( "f", "list", Tm_SetListName ); // exec all registered command line options if ( !OPT_ExecRegisteredOptions( argc, argv ) ) { Err_Printf( options_invalid ); Exit( EXIT_FAILURE ); } // package name is mandatory if ( arg_package_name[ 0 ] == 0 ) { Err_Printf( pack_name_missing ); Exit( EXIT_FAILURE ); } // list name is optional (use package with different extension by default) if ( arg_list_name[ 0 ] == 0 ) { strcpy( arg_list_name, arg_package_name ); StripExtension( arg_list_name ); strcat( arg_list_name, ".lst" ); } // create package CreatePackage( arg_package_name, arg_list_name ); // end of sub-application Exit( EXIT_SUCCESS ); }
/* =============== Curve_WriteFile =============== */ void Curve_WriteFile (char *name) { char curveName[1024]; brush_t *b; curveBlock_t *cb; time_t ltime; strcpy(curveName, name); StripExtension (curveName); strcat (curveName, ".bnd"); curveFile = fopen(curveName, "w"); if (!curveFile) { return; } time(<ime); fprintf (curveFile, "// %s saved on %s\n", name, ctime(<ime) ); for (b=world_entity->brushes.onext ; b != &world_entity->brushes ; b=b->onext) { if (!b->curveBrush) { continue; // only write curve brushes } cb = BrushToCurveBlock(b); SubdivideCurveBlock (cb); } fclose (curveFile); curveFile = NULL; }
void LoadTriangleList(const char *fileName, triangle_t **triList, int *triangleCount) { FILE *input; q_strlcpy(InputFileName, fileName, sizeof(InputFileName)); StripExtension(InputFileName); q_strlcat(InputFileName, ".asc", sizeof(InputFileName)); if ((input = fopen(InputFileName, "rb")) != NULL) { fclose(input); LoadASC(InputFileName, triList, triangleCount); return; } StripExtension(InputFileName); q_strlcat(InputFileName, ".hrc", sizeof(InputFileName)); if ((input = fopen(InputFileName, "rb")) != NULL) { fclose(input); LoadHRC(InputFileName, triList, triangleCount); return; } StripExtension(InputFileName); q_strlcat(InputFileName, ".htr", sizeof(InputFileName)); if ((input = fopen(InputFileName, "rb")) != NULL) { fclose(input); LoadHTR(InputFileName, triList, triangleCount); return; } StripExtension(InputFileName); q_strlcat(InputFileName, ".tri", sizeof(InputFileName)); if ((input = fopen(InputFileName, "rb")) != NULL) { LoadTRI(input, triList, triangleCount); fclose(input); return; } COM_Error("Could not open file '%s':\n" "No ASC, HRC, HTR, or TRI match.\n", fileName); }
/* * @brief */ static void S_LoadSampleChunk(s_sample_t *sample) { char path[MAX_QPATH]; void *buf; int32_t i, len; SDL_RWops *rw; if (sample->media.name[0] == '*') // place holder return; if (sample->media.name[0] == '#') { // global path g_strlcpy(path, (sample->media.name + 1), sizeof(path)); } else { // or relative g_snprintf(path, sizeof(path), "sounds/%s", sample->media.name); } buf = NULL; rw = NULL; i = 0; while (SAMPLE_TYPES[i]) { StripExtension(path, path); g_strlcat(path, SAMPLE_TYPES[i++], sizeof(path)); if ((len = Fs_Load(path, &buf)) == -1) continue; if (!(rw = SDL_RWFromMem(buf, len))) { Fs_Free(buf); continue; } if (!(sample->chunk = Mix_LoadWAV_RW(rw, false))) Com_Warn("%s\n", Mix_GetError()); Fs_Free(buf); SDL_FreeRW(rw); if (sample->chunk) { // success break; } } if (sample->chunk) { Mix_VolumeChunk(sample->chunk, s_volume->value * MIX_MAX_VOLUME); Com_Debug("Loaded %s\n", path); } else { if (g_str_has_prefix(sample->media.name, "#players")) { Com_Debug("Failed to load player sample %s\n", sample->media.name); } else { Com_Warn("Failed to load %s\n", sample->media.name); } } }
int BSPInfo( int count, char **fileNames ) { int i; char source[ 1024 ], ext[ 64 ]; int size; FILE *f; /* dummy check */ if( count < 1 ) { Sys_Printf( "No files to dump info for.\n"); return -1; } /* enable info mode */ infoMode = qtrue; /* walk file list */ for( i = 0; i < count; i++ ) { Sys_Printf( "---------------------------------\n" ); /* mangle filename and get size */ strcpy( source, fileNames[ i ] ); ExtractFileExtension( source, ext ); if( !Q_stricmp( ext, "map" ) ) StripExtension( source ); DefaultExtension( source, ".bsp" ); f = fopen( source, "rb" ); if( f ) { size = Q_filelength (f); fclose( f ); } else size = 0; /* load the bsp file and print lump sizes */ Sys_Printf( "%s\n", source ); LoadBSPFile( source ); PrintBSPFileSizes(); /* print sizes */ Sys_Printf( "\n" ); Sys_Printf( " total %9d\n", size ); Sys_Printf( " %9d KB\n", size / 1024 ); Sys_Printf( " %9d MB\n", size / (1024 * 1024) ); Sys_Printf( "---------------------------------\n" ); } /* return count */ return i; }
/* * BSP_Main */ int BSP_Main(void){ time_t start, end; char base[MAX_OSPATH]; int total_bsp_time; #ifdef _WIN32 char title[MAX_OSPATH]; sprintf(title, "Q2WMap [Compiling BSP]"); SetConsoleTitle(title); #endif Com_Print("\n----- BSP -----\n\n"); start = time(NULL); StripExtension(map_name, base); // clear the whole bsp structure memset(&d_bsp, 0, sizeof(d_bsp)); // delete portal and line files remove(va("%s.prt", base)); remove(va("%s.lin", base)); // if onlyents, just grab the entities and re-save if(onlyents){ LoadBSPFile(bsp_name); num_entities = 0; LoadMapFile(map_name); SetModelNumbers(); UnparseEntities(); WriteBSPFile(bsp_name); } else { // start from scratch LoadMapFile(map_name); SetModelNumbers(); ProcessModels(); } end = time(NULL); total_bsp_time = (int)(end - start); Com_Print("\nBSP Time: "); if(total_bsp_time > 59) Com_Print("%d Minutes ", total_bsp_time / 60); Com_Print("%d Seconds\n", total_bsp_time % 60); return 0; }
/* =========== Map_SaveFile \todo FIXME remove the use_region, this is broken .. work with a global flag to set region mode or not =========== */ void Map_SaveFile( const char *filename, qboolean use_region ){ clock_t start, finish; double elapsed_time; start = clock(); Sys_Printf( "Saving map to %s\n",filename ); Pointfile_Clear(); if ( !use_region ) { char backup[1024]; // rename current to .bak strcpy( backup, filename ); StripExtension( backup ); strcat( backup, ".bak" ); unlink( backup ); rename( filename, backup ); } Sys_Printf( "Map_SaveFile: %s\n", filename ); // build the out data stream FileStream file; if ( !file.Open( filename,"w" ) ) { Sys_FPrintf( SYS_ERR, "ERROR: couldn't open %s for write\n", filename ); return; } // extract filetype Map_Export( &file, filename_get_extension( filename ), use_region ); file.Close(); finish = clock(); elapsed_time = (double)( finish - start ) / CLOCKS_PER_SEC; Sys_Printf( "Saved in %-.2f second(s).\n",elapsed_time ); modified = false; if ( !strstr( filename, "autosave" ) ) { Sys_SetTitle( filename ); } if ( !use_region ) { time_t timer; time( &timer ); Sys_Beep(); Sys_Status( "Saved.", 0 ); } }
void AddMissionsToTree(char *path, GtkWidget *tree, int is_parent) { glob_t *search; unsigned int length; int count, max; char *file, *filename; GtkWidget *subtree, *item; // First we check for sub directories. stick them at the top // For some reason, glob(,,GLOB_ONLYDIR,) doesn't seem to only match directories, // so FindDirs() currently returns everything. Check the last char for a / // That will be the directory. search = FindDirs(path); max = search->gl_pathc - 1; // search->gl_pathc is a uint. If there's no files, it's 0. for (count = 0; count <= max; count++) { file = search->gl_pathv[count]; length = strlen(file); if (file[length-1] != SEPERATOR) { continue; } // Verify it's a directory and not a file filename = strdup(file); filename = StripPath(filename); if (strcmp("CVS", filename) == 0) { continue; } // Don't need to display this directory item = AddItem(tree, filename, "dir"); subtree = gtk_tree_new(); gtk_signal_connect(GTK_OBJECT(subtree), "select_child", GTK_SIGNAL_FUNC(cb_select_child), subtree); gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child", GTK_SIGNAL_FUNC(cb_unselect_child), subtree); gtk_tree_set_selection_mode(GTK_TREE(subtree), GTK_SELECTION_SINGLE); gtk_tree_set_view_mode(GTK_TREE(subtree), GTK_TREE_VIEW_ITEM); gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree); AddMissionsToTree(file, subtree, 0); } search = FindFiles(path, EXT_MISSION); max = search->gl_pathc - 1; for (count = 0; count <= max; count++) { file = search->gl_pathv[count]; length = strlen(file); if (file[length-1] == SEPERATOR) { continue; } filename = strdup(file); filename = StripPath(filename); StripExtension(filename); AddItem(tree, filename, file); } return; }
bool SHGToMap(wxChar *filename, wxChar *defaultFile) { // Test the SHG parser HotSpot *hotspots = NULL; int n = ParseSHG(filename, &hotspots); if (n == 0) return false; wxChar buf[100]; wxSnprintf(buf, sizeof(buf), _T("Converting .SHG file to HTML map file: there are %d hotspots in %s."), n, filename); OnInform(buf); wxChar outBuf[256]; wxStrcpy(outBuf, filename); StripExtension(outBuf); wxStrcat(outBuf, _T(".map")); FILE *fd = wxFopen(outBuf, _T("w")); if (!fd) { OnError(_T("Could not open .map file for writing.")); delete[] hotspots; return false; } wxFprintf(fd, _T("default %s\n"), defaultFile); for (int i = 0; i < n; i++) { wxChar *refFilename = _T("??"); TexRef *texRef = FindReference(hotspots[i].szHlpTopic_Macro); if (texRef) refFilename = texRef->refFile; else { wxChar buf[300]; wxSnprintf(buf, sizeof(buf), _T("Warning: could not find hotspot reference %s"), hotspots[i].szHlpTopic_Macro); OnInform(buf); } wxFprintf(fd, _T("rect %s %d %d %d %d\n"), refFilename, (int)hotspots[i].left, (int)hotspots[i].top, (int)hotspots[i].right, (int)hotspots[i].bottom); } wxFprintf(fd, _T("\n")); fclose(fd); delete[] hotspots; return true; }
int RobotWorld::LoadTerrain(const string& fn) { Environment* t = new Environment; if(!t->Load(fn.c_str())) { delete t; return -1; } const char* justfn = GetFileName(fn.c_str()); char* buf = new char[strlen(justfn)+1]; strcpy(buf,justfn); StripExtension(buf); string name=buf; delete [] buf; int i = AddTerrain(name,t); return i; }
int RobotWorld::LoadRigidObject(const string& fn) { RigidObject* t = new RigidObject; if(!t->Load(fn.c_str())) { delete t; return -1; } const char* justfn = GetFileName(fn.c_str()); char* buf = new char[strlen(justfn)+1]; strcpy(buf,justfn); StripExtension(buf); string name=buf; delete [] buf; int i = AddRigidObject(name,t); return i; }
IFaceposerModels::CFacePoserModel::CFacePoserModel( char const *modelfile, StudioModel *model ) { m_pModel = model; m_szActorName[ 0 ] = 0; m_szShortName[ 0 ] = 0; strcpy( m_szModelFileName, modelfile ); studiohdr_t *hdr = model->getStudioHeader(); if ( hdr ) { strcpy( m_szShortName, hdr->name ); StripExtension( m_szShortName ); } m_bVisibileIn3DView = false; }
void WINAPI Pointfile_Check (void) { char name[1024]; FILE *f; idVec3 v; strcpy (name, currentmap); StripExtension (name); strcat (name, ".lin"); f = fopen (name, "r"); if (!f) return; common->Printf ("Reading pointfile %s\n", name); if (!g_qeglobals.d_pointfile_display_list) g_qeglobals.d_pointfile_display_list = qglGenLists(1); s_num_points = 0; qglNewList (g_qeglobals.d_pointfile_display_list, GL_COMPILE); qglColor3f (1, 0, 0); qglDisable(GL_TEXTURE_2D); qglDisable(GL_TEXTURE_1D); qglLineWidth (2); qglBegin(GL_LINE_STRIP); do { if (fscanf (f, "%f %f %f\n", &v[0], &v[1], &v[2]) != 3) break; if (s_num_points < MAX_POINTFILE) { VectorCopy (v, s_pointvecs[s_num_points]); s_num_points++; } qglVertex3fv( v.ToFloatPtr() ); } while (1); qglEnd(); qglLineWidth (0.5); qglEndList (); s_check_point = 0; fclose (f); //Pointfile_Next (); }
/* ============= WriteBSPFile ============= */ void WriteBSPFile(void) { FILE *f; size_t ret; header = AllocMem(OTHER, sizeof(dheader_t), true); header->version = options.BSPVersion; StripExtension(options.szBSPName); strcat(options.szBSPName, ".bsp"); f = fopen(options.szBSPName, "wb"); if (!f) Error("Failed to open %s: %s", options.szBSPName, strerror(errno)); /* write placeholder, header is overwritten later */ ret = fwrite(header, sizeof(dheader_t), 1, f); if (ret != 1) Error("Failure writing to file"); AddLump(f, LUMP_PLANES); AddLump(f, LUMP_LEAFS); AddLump(f, LUMP_VERTEXES); AddLump(f, LUMP_NODES); AddLump(f, LUMP_TEXINFO); AddLump(f, LUMP_FACES); AddLump(f, LUMP_CLIPNODES); AddLump(f, LUMP_MARKSURFACES); AddLump(f, LUMP_SURFEDGES); AddLump(f, LUMP_EDGES); AddLump(f, LUMP_MODELS); AddLump(f, LUMP_LIGHTING); AddLump(f, LUMP_VISIBILITY); AddLump(f, LUMP_ENTITIES); AddLump(f, LUMP_TEXTURES); fseek(f, 0, SEEK_SET); ret = fwrite(header, sizeof(dheader_t), 1, f); if (ret != 1) Error("Failure writing to file"); fclose(f); FreeMem(header, OTHER, sizeof(dheader_t)); }
/* * @brief */ int32_t BSP_Main(void) { char base[MAX_OSPATH]; Com_Print("\n----- BSP -----\n\n"); const time_t start = time(NULL); StripExtension(map_name, base); // clear the whole bsp structure memset(&d_bsp, 0, sizeof(d_bsp)); // delete portal and line files remove(va("%s.prt", base)); remove(va("%s.lin", base)); // if onlyents, just grab the entities and re-save if (onlyents) { LoadBSPFile(bsp_name); num_entities = 0; LoadMapFile(map_name); SetModelNumbers(); UnparseEntities(); WriteBSPFile(bsp_name); } else { // start from scratch LoadMapFile(map_name); SetModelNumbers(); ProcessModels(); } const time_t end = time(NULL); const time_t duration = end - start; Com_Print("\nBSP Time: "); if (duration > 59) Com_Print("%d Minutes ", (int32_t) (duration / 60)); Com_Print("%d Seconds\n", (int32_t) (duration % 60)); return 0; }