Quake-III-Arena

bspc.c (28389B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code is free software; you can redistribute it
 and/or modify it under the terms of the GNU General Public License as
 published by the Free Software Foundation; either version 2 of the License,
 or (at your option) any later version.
 
 Quake III Arena source code is distributed in the hope that it will be
 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
 #if defined(WIN32) || defined(_WIN32)
 #include <direct.h>
 #include <windows.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #else
 #include <unistd.h>
 #include <glob.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
 #include "qbsp.h"
 #include "l_mem.h"
 #include "../botlib/aasfile.h"
 #include "../botlib/be_aas_cluster.h"
 #include "../botlib/be_aas_optimize.h"
 #include "aas_create.h"
 #include "aas_store.h"
 #include "aas_file.h"
 #include "aas_cfg.h"
 #include "be_aas_bspc.h"
 
 extern	int use_nodequeue;		//brushbsp.c
 extern	int calcgrapplereach;	//be_aas_reach.c
 
 float			subdivide_size = 240;
 char			source[1024];
 char			name[1024];
 vec_t			microvolume = 1.0;
 char			outbase[32];
 int				entity_num;
 aas_settings_t	aassettings;
 
 qboolean	noprune;			//don't prune nodes (bspc.c)
 qboolean	glview;				//create a gl view
 qboolean	nodetail;			//don't use detail brushes (map.c)
 qboolean	fulldetail;			//use but don't mark detail brushes (map.c)
 qboolean	onlyents;			//only process the entities (bspc.c)
 qboolean	nomerge;			//don't merge bsp node faces (faces.c)
 qboolean	nowater;			//don't use the water brushes (map.c)
 qboolean	nocsg;				//don't carve intersecting brushes (bspc.c)
 qboolean	noweld;				//use unique face vertexes (faces.c)
 qboolean	noshare;			//don't share bsp edges (faces.c)
 qboolean	nosubdiv;			//don't subdivide bsp node faces (faces.c)
 qboolean	notjunc;			//don't create tjunctions (edge melting) (faces.c)
 qboolean	optimize;			//enable optimisation
 qboolean	leaktest;			//perform a leak test
 qboolean	verboseentities;
 qboolean	freetree;			//free the bsp tree when not needed anymore
 qboolean	create_aas;			//create an .AAS file
 qboolean	nobrushmerge;		//don't merge brushes
 qboolean	lessbrushes;		//create less brushes instead of correct texture placement
 qboolean	cancelconversion;	//true if the conversion is being cancelled
 qboolean	noliquids;			//no liquids when writing map file
 qboolean	forcesidesvisible;	//force all brush sides to be visible when loaded from bsp
 qboolean	capsule_collision = 0;
 
 /*
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void ProcessWorldModel (void)
 {
 	entity_t	*e;
 	tree_t *tree;
 	qboolean	leaked;
 	int brush_start, brush_end;
 
 	e = &entities[entity_num];
 
 	brush_start = e->firstbrush;
 	brush_end = brush_start + e->numbrushes;
 	leaked = false;
 
 	//process the whole world in one time
 	tree = ProcessWorldBrushes(brush_start, brush_end);
 	//create the bsp tree portals
 	MakeTreePortals(tree);
 	//mark all leafs that can be reached by entities
 	if (FloodEntities(tree))
 	{
 		FillOutside(tree->headnode);
 	} //end if
 	else
 	{
 		Log_Print("**** leaked ****\n");
 		leaked = true;
 		LeakFile(tree);
 		if (leaktest)
 		{
 			Log_Print("--- MAP LEAKED ---\n");
 			exit(0);
 		} //end if
 	} //end else
 
 	MarkVisibleSides (tree, brush_start, brush_end);
 
 	FloodAreas (tree);
 
 #ifndef ME
 	if (glview) WriteGLView(tree, source);
 #endif
 	MakeFaces(tree->headnode);
 	FixTjuncs(tree->headnode);
 
 	//NOTE: Never prune the nodes because the portals
 	//		are screwed when prunning is done and as
 	//		a result portal writing will crash
 	//if (!noprune) PruneNodes(tree->headnode);
 
 	WriteBSP(tree->headnode);
 
 	if (!leaked) WritePortalFile(tree);
 
 	Tree_Free(tree);
 } //end of the function ProcessWorldModel
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void ProcessSubModel (void)
 {
 	entity_t	*e;
 	int start, end;
 	tree_t *tree;
 	bspbrush_t *list;
 	vec3_t mins, maxs;
 
 	e = &entities[entity_num];
 
 	start = e->firstbrush;
 	end = start + e->numbrushes;
 
 	mins[0] = mins[1] = mins[2] = -4096;
 	maxs[0] = maxs[1] = maxs[2] = 4096;
 	list = MakeBspBrushList(start, end, mins, maxs);
 	if (!nocsg) list = ChopBrushes (list);
 	tree = BrushBSP (list, mins, maxs);
 	MakeTreePortals (tree);
 	MarkVisibleSides (tree, start, end);
 	MakeFaces (tree->headnode);
 	FixTjuncs (tree->headnode);
 	WriteBSP (tree->headnode);
 	Tree_Free(tree);
 } //end of the function ProcessSubModel
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void ProcessModels (void)
 {
 	BeginBSPFile();
 
 	for (entity_num = 0; entity_num < num_entities; entity_num++)
 	{
 		if (!entities[entity_num].numbrushes)
 			continue;
 
 		Log_Print("############### model %i ###############\n", nummodels);
 		BeginModel();
 		if (entity_num == 0) ProcessWorldModel();
 		else ProcessSubModel();
 		EndModel();
 
 		if (!verboseentities)
 			verbose = false;	// don't bother printing submodels
 	} //end for
 	EndBSPFile();
 } //end of the function ProcessModels
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void Win_Map2Bsp(char *bspfilename)
 {
 	double start, end;
 	char path[1024];
 
 	start = I_FloatTime();
 
 	ThreadSetDefault();
 	//yeah sure Carmack
 	//numthreads = 1;		// multiple threads aren't helping...
 
 	strcpy(source, ExpandArg(bspfilename));
 	StripExtension(source);
 
 	//delete portal and line files
 	sprintf(path, "%s.prt", source);
 	remove(path);
 	sprintf(path, "%s.lin", source);
 	remove(path);
 
 	strcpy(name, ExpandArg(bspfilename));	
 	DefaultExtension(name, ".map");	// might be .reg
 
 	Q2_AllocMaxBSP();
 	//
 	SetModelNumbers();
 	SetLightStyles();
 	ProcessModels();
 	//write the BSP
 	Q2_WriteBSPFile(bspfilename);
 
 	Q2_FreeMaxBSP();
 
 	end = I_FloatTime();
 	Log_Print("%5.0f seconds elapsed\n", end-start);
 } //end of the function Win_Map2Bsp
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void Map2Bsp(char *mapfilename, char *outputfilename)
 {
 	double start, end;
 	char path[1024];
 
 	start = I_FloatTime ();
 
 	ThreadSetDefault ();
 	//yeah sure Carmack
 	//numthreads = 1;		//multiple threads aren't helping...
 	//SetQdirFromPath(bspfilename);
 
 	strcpy(source, ExpandArg(mapfilename));
 	StripExtension(source);
 
 	// delete portal and line files
 	sprintf(path, "%s.prt", source);
 	remove(path);
 	sprintf(path, "%s.lin", source);
 	remove(path);
 
 	strcpy(name, ExpandArg(mapfilename));
 	DefaultExtension(name, ".map");	// might be .reg
 
 	//
 	// if onlyents, just grab the entites and resave
 	//
 	if (onlyents)
 	{
 		char out[1024];
 
 		Q2_AllocMaxBSP();
 		sprintf (out, "%s.bsp", source);
 		Q2_LoadBSPFile(out, 0, 0);
 		num_entities = 0;
 
 		Q2_LoadMapFile(name);
 		SetModelNumbers();
 		SetLightStyles();
 
 		Q2_UnparseEntities();
 
 		Q2_WriteBSPFile(out);
 		//
 		Q2_FreeMaxBSP();
 	} //end if
 	else
 	{
 		//
 		// start from scratch
 		//
 		Q2_AllocMaxBSP();
 		//load the map
 		Q2_LoadMapFile(name);
 		//create the .bsp file
 		SetModelNumbers();
 		SetLightStyles();
 		ProcessModels();
 		//write the BSP
 		Q2_WriteBSPFile(outputfilename);
 		//
 		Q2_FreeMaxBSP();
 	} //end else
 
 	end = I_FloatTime();
 	Log_Print("%5.0f seconds elapsed\n", end-start);
 } //end of the function Map2Bsp
 */
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void AASOuputFile(quakefile_t *qf, char *outputpath, char *filename)
 {
 	char ext[MAX_PATH];
 
 	//
 	if (strlen(outputpath))
 	{
 		strcpy(filename, outputpath);
 		//append the bsp file base
 		AppendPathSeperator(filename, MAX_PATH);
 		ExtractFileBase(qf->origname, &filename[strlen(filename)]);
 		//append .aas
 		strcat(filename, ".aas");
 		return;
 	} //end if
 	//
 	ExtractFileExtension(qf->filename, ext);
 	if (!stricmp(ext, "pk3") || !stricmp(ext, "pak") || !stricmp(ext, "sin"))
 	{
 		strcpy(filename, qf->filename);
 		while(strlen(filename) &&
 				filename[strlen(filename)-1] != '\\' &&
 				filename[strlen(filename)-1] != '/')
 		{
 			filename[strlen(filename)-1] = '\0';
 		} //end while
 		strcat(filename, "maps");
 		if (access(filename, 0x04)) CreatePath(filename);
 		//append the bsp file base
 		AppendPathSeperator(filename, MAX_PATH);
 		ExtractFileBase(qf->origname, &filename[strlen(filename)]);
 		//append .aas
 		strcat(filename, ".aas");
 	} //end if
 	else
 	{
 		strcpy(filename, qf->filename);
 		while(strlen(filename) &&
 				filename[strlen(filename)-1] != '.')
 		{
 			filename[strlen(filename)-1] = '\0';
 		} //end while
 		strcat(filename, "aas");
 	} //end else
 } //end of the function AASOutputFile
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void CreateAASFilesForAllBSPFiles(char *quakepath)
 {
 #if defined(WIN32)|defined(_WIN32)
 	WIN32_FIND_DATA filedata;
 	HWND handle;
 	struct _stat statbuf;
 #else
 	glob_t globbuf;
 	struct stat statbuf;
 	int j;
 #endif
 	int done;
 	char filter[_MAX_PATH], bspfilter[_MAX_PATH], aasfilter[_MAX_PATH];
 	char aasfile[_MAX_PATH], buf[_MAX_PATH], foldername[_MAX_PATH];
 	quakefile_t *qf, *qf2, *files, *bspfiles, *aasfiles;
 
 	strcpy(filter, quakepath);
 	AppendPathSeperator(filter, sizeof(filter));
 	strcat(filter, "*");
 
 #if defined(WIN32)|defined(_WIN32)
 	handle = FindFirstFile(filter, &filedata);
 	done = (handle == INVALID_HANDLE_VALUE);
 	while(!done)
 	{
 		_splitpath(filter, foldername, NULL, NULL, NULL);
 		_splitpath(filter, NULL, &foldername[strlen(foldername)], NULL, NULL);
 		AppendPathSeperator(foldername, _MAX_PATH);
 		strcat(foldername, filedata.cFileName);
 		_stat(foldername, &statbuf);
 #else
 	glob(filter, 0, NULL, &globbuf);
 	for (j = 0; j < globbuf.gl_pathc; j++)
 	{
 		strcpy(foldername, globbuf.gl_pathv[j]);
 		stat(foldername, &statbuf);
 #endif
 		//if it is a folder
 		if (statbuf.st_mode & S_IFDIR)
 		{
 			//
 			AppendPathSeperator(foldername, sizeof(foldername));
 			//get all the bsp files
 			strcpy(bspfilter, foldername);
 			strcat(bspfilter, "maps/*.bsp");
 			files = FindQuakeFiles(bspfilter);
 			strcpy(bspfilter, foldername);
 			strcat(bspfilter, "*.pk3/maps/*.bsp");
 			bspfiles = FindQuakeFiles(bspfilter);
 			for (qf = bspfiles; qf; qf = qf->next) if (!qf->next) break;
 			if (qf) qf->next = files;
 			else bspfiles = files;
 			//get all the aas files
 			strcpy(aasfilter, foldername);
 			strcat(aasfilter, "maps/*.aas");
 			files = FindQuakeFiles(aasfilter);
 			strcpy(aasfilter, foldername);
 			strcat(aasfilter, "*.pk3/maps/*.aas");
 			aasfiles = FindQuakeFiles(aasfilter);
 			for (qf = aasfiles; qf; qf = qf->next) if (!qf->next) break;
 			if (qf) qf->next = files;
 			else aasfiles = files;
 			//
 			for (qf = bspfiles; qf; qf = qf->next)
 			{
 				sprintf(aasfile, "%s/%s", qf->pakfile, qf->origname);
 				Log_Print("found %s\n", aasfile);
 				strcpy(&aasfile[strlen(aasfile)-strlen(".bsp")], ".aas");
 				for (qf2 = aasfiles; qf2; qf2 = qf2->next)
 				{
 					sprintf(buf, "%s/%s", qf2->pakfile, qf2->origname);
 					if (!stricmp(aasfile, buf))
 					{
 						Log_Print("found %s\n", buf);
 						break;
 					} //end if
 				} //end for
 			} //end for
 		} //end if
 #if defined(WIN32)|defined(_WIN32)
 		//find the next file
 		done = !FindNextFile(handle, &filedata);
 	} //end while
 #else
 	} //end for
 	globfree(&globbuf);
 #endif
 } //end of the function CreateAASFilesForAllBSPFiles
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 quakefile_t *GetArgumentFiles(int argc, char *argv[], int *i, char *ext)
 {
 	quakefile_t *qfiles, *lastqf, *qf;
 	int j;
 	char buf[1024];
 
 	qfiles = NULL;
 	lastqf = NULL;
 	for (; (*i)+1 < argc && argv[(*i)+1][0] != '-'; (*i)++)
 	{
 		strcpy(buf, argv[(*i)+1]);
 		for (j = strlen(buf)-1; j >= strlen(buf)-4; j--)
 			if (buf[j] == '.') break;
 		if (j >= strlen(buf)-4)
 			strcpy(&buf[j+1], ext);
 		qf = FindQuakeFiles(buf);
 		if (!qf) continue;
 		if (lastqf) lastqf->next = qf;
 		else qfiles = qf;
 		lastqf = qf;
 		while(lastqf->next) lastqf = lastqf->next;
 	} //end for
 	return qfiles;
 } //end of the function GetArgumentFiles
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 
 #define COMP_BSP2MAP		1
 #define COMP_BSP2AAS		2
 #define COMP_REACH			3
 #define COMP_CLUSTER		4
 #define COMP_AASOPTIMIZE	5
 #define COMP_AASINFO		6
 
 int main (int argc, char **argv)
 {
 	int i, comp = 0;
 	char outputpath[MAX_PATH] = "";
 	char filename[MAX_PATH] = "unknown";
 	quakefile_t *qfiles, *qf;
 	double start_time;
 
 	myargc = argc;
 	myargv = argv;
 
 	start_time = I_FloatTime();
 
 	Log_Open("bspc.log");		//open a log file
 	Log_Print("BSPC version "BSPC_VERSION", %s %s\n", __DATE__, __TIME__);
 
 	DefaultCfg();
 	for (i = 1; i < argc; i++)
 	{
 		if (!stricmp(argv[i],"-threads"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			numthreads = atoi(argv[++i]);
 			Log_Print("threads = %d\n", numthreads);
 		} //end if
 		else if (!stricmp(argv[i], "-noverbose"))
 		{
 			Log_Print("verbose = false\n");
 			verbose = false;
 		} //end else if
 		else if (!stricmp(argv[i], "-nocsg"))
 		{
 			Log_Print("nocsg = true\n");
 			nocsg = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-optimize"))
 		{
 			Log_Print("optimize = true\n");
 			optimize = true;
 		} //end else if
 		/*
 		else if (!stricmp(argv[i],"-glview"))
 		{
 			glview = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-draw"))
 		{
 			Log_Print("drawflag = true\n");
 			drawflag = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-noweld"))
 		{
 			Log_Print("noweld = true\n");
 			noweld = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-noshare"))
 		{
 			Log_Print("noshare = true\n");
 			noshare = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-notjunc"))
 		{
 			Log_Print("notjunc = true\n");
 			notjunc = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-nowater"))
 		{
 			Log_Print("nowater = true\n");
 			nowater = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-noprune"))
 		{
 			Log_Print("noprune = true\n");
 			noprune = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-nomerge"))
 		{
 			Log_Print("nomerge = true\n");
 			nomerge = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-nosubdiv"))
 		{
 			Log_Print("nosubdiv = true\n");
 			nosubdiv = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-nodetail"))
 		{
 			Log_Print("nodetail = true\n");
 			nodetail = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-fulldetail"))
 		{
 			Log_Print("fulldetail = true\n");
 			fulldetail = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-onlyents"))
 		{
 			Log_Print("onlyents = true\n");
 			onlyents = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-micro"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			microvolume = atof(argv[++i]);
 			Log_Print("microvolume = %f\n", microvolume);
 		} //end else if
 		else if (!stricmp(argv[i], "-leaktest"))
 		{
 			Log_Print("leaktest = true\n");
 			leaktest = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-verboseentities"))
 		{
 			Log_Print("verboseentities = true\n");
 			verboseentities = true;
 		} //end else if
 		else if (!stricmp(argv[i], "-chop"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			subdivide_size = atof(argv[++i]);
 			Log_Print("subdivide_size = %f\n", subdivide_size);
 		} //end else if
 		else if (!stricmp (argv[i], "-tmpout"))
 		{
 			strcpy (outbase, "/tmp");
 			Log_Print("temp output\n");
 		} //end else if
 		*/
 #ifdef ME
 		else if (!stricmp(argv[i], "-freetree"))
 		{
 			freetree = true;
 			Log_Print("freetree = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-grapplereach"))
 		{
 			calcgrapplereach = true;
 			Log_Print("grapplereach = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-nobrushmerge"))
 		{
 			nobrushmerge = true;
 			Log_Print("nobrushmerge = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-noliquids"))
 		{
 			noliquids = true;
 			Log_Print("noliquids = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-forcesidesvisible"))
 		{
 			forcesidesvisible = true;
 			Log_Print("forcesidesvisible = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-output"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			if (access(argv[i+1], 0x04)) Warning("the folder %s does not exist", argv[i+1]);
 			strcpy(outputpath, argv[++i]);
 		} //end else if
 		else if (!stricmp(argv[i], "-breadthfirst"))
 		{
 			use_nodequeue = true;
 			Log_Print("breadthfirst = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-capsule"))
 		{
 			capsule_collision = true;
 			Log_Print("capsule_collision = true\n");
 		} //end else if
 		else if (!stricmp(argv[i], "-cfg"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			if (!LoadCfgFile(argv[++i]))
 				exit(0);
 		} //end else if
 		else if (!stricmp(argv[i], "-bsp2map"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_BSP2MAP;
 			qfiles = GetArgumentFiles(argc, argv, &i, "bsp");
 		} //end else if
 		else if (!stricmp(argv[i], "-bsp2aas"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_BSP2AAS;
 			qfiles = GetArgumentFiles(argc, argv, &i, "bsp");
 		} //end else if
 		else if (!stricmp(argv[i], "-aasall"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			CreateAASFilesForAllBSPFiles(argv[++i]);
 		} //end else if
 		else if (!stricmp(argv[i], "-reach"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_REACH;
 			qfiles = GetArgumentFiles(argc, argv, &i, "bsp");
 		} //end else if
 		else if (!stricmp(argv[i], "-cluster"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_CLUSTER;
 			qfiles = GetArgumentFiles(argc, argv, &i, "bsp");
 		} //end else if
 		else if (!stricmp(argv[i], "-aasinfo"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_AASINFO;
 			qfiles = GetArgumentFiles(argc, argv, &i, "aas");
 		} //end else if
 		else if (!stricmp(argv[i], "-aasopt"))
 		{
 			if (i + 1 >= argc) {i = 0; break;}
 			comp = COMP_AASOPTIMIZE;
 			qfiles = GetArgumentFiles(argc, argv, &i, "aas");
 		} //end else if
 #endif //ME
 		else
 		{
 			Log_Print("unknown parameter %s\n", argv[i]);
 			break;
 		} //end else
 	} //end for
 
 	//if there are parameters and there's no mismatch in one of the parameters
 	if (argc > 1 && i == argc)
 	{
 		switch(comp)
 		{
 			case COMP_BSP2MAP:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					//copy the output path
 					strcpy(filename, outputpath);
 					//append the bsp file base
 					AppendPathSeperator(filename, MAX_PATH);
 					ExtractFileBase(qf->origname, &filename[strlen(filename)]);
 					//append .map
 					strcat(filename, ".map");
 					//
 					Log_Print("bsp2map: %s to %s\n", qf->origname, filename);
 					if (qf->type != QFILETYPE_BSP) Warning("%s is probably not a BSP file\n", qf->origname);
 					//
 					LoadMapFromBSP(qf);
 					//write the map file
 					WriteMapFile(filename);
 				} //end for
 				break;
 			} //end case
 			case COMP_BSP2AAS:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					AASOuputFile(qf, outputpath, filename);
 					//
 					Log_Print("bsp2aas: %s to %s\n", qf->origname, filename);
 					if (qf->type != QFILETYPE_BSP) Warning("%s is probably not a BSP file\n", qf->origname);
 					//set before map loading
 					create_aas = 1;
 					LoadMapFromBSP(qf);
 					//create the AAS file
 					AAS_Create(filename);
 					//if it's a Quake3 map calculate the reachabilities and clusters
 					if (loadedmaptype == MAPTYPE_QUAKE3) AAS_CalcReachAndClusters(qf);
 					//
 					if (optimize) AAS_Optimize();
 					//
 					//write out the stored AAS file
 					if (!AAS_WriteAASFile(filename))
 					{
 						Error("error writing %s\n", filename);
 					} //end if
 					//deallocate memory
 					AAS_FreeMaxAAS();
 				} //end for
 				break;
 			} //end case
 			case COMP_REACH:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					AASOuputFile(qf, outputpath, filename);
 					//
 					Log_Print("reach: %s to %s\n", qf->origname, filename);
 					if (qf->type != QFILETYPE_BSP) Warning("%s is probably not a BSP file\n", qf->origname);
 					//if the AAS file exists in the output directory
 					if (!access(filename, 0x04))
 					{
 						if (!AAS_LoadAASFile(filename, 0, 0))
 						{
 							Error("error loading aas file %s\n", filename);
 						} //end if
 						//assume it's a Quake3 BSP file
 						loadedmaptype = MAPTYPE_QUAKE3;
 					} //end if
 					else
 					{
 						Warning("AAS file %s not found in output folder\n", filename);
 						Log_Print("creating %s...\n", filename);
 						//set before map loading
 						create_aas = 1;
 						LoadMapFromBSP(qf);
 						//create the AAS file
 						AAS_Create(filename);
 					} //end else
 					//if it's a Quake3 map calculate the reachabilities and clusters
 					if (loadedmaptype == MAPTYPE_QUAKE3)
 					{
 						AAS_CalcReachAndClusters(qf);
 					} //end if
 					//
 					if (optimize) AAS_Optimize();
 					//write out the stored AAS file
 					if (!AAS_WriteAASFile(filename))
 					{
 						Error("error writing %s\n", filename);
 					} //end if
 					//deallocate memory
 					AAS_FreeMaxAAS();
 				} //end for
 				break;
 			} //end case
 			case COMP_CLUSTER:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					AASOuputFile(qf, outputpath, filename);
 					//
 					Log_Print("cluster: %s to %s\n", qf->origname, filename);
 					if (qf->type != QFILETYPE_BSP) Warning("%s is probably not a BSP file\n", qf->origname);
 					//if the AAS file exists in the output directory
 					if (!access(filename, 0x04))
 					{
 						if (!AAS_LoadAASFile(filename, 0, 0))
 						{
 							Error("error loading aas file %s\n", filename);
 						} //end if
 						//assume it's a Quake3 BSP file
 						loadedmaptype = MAPTYPE_QUAKE3;
 						//if it's a Quake3 map calculate the clusters
 						if (loadedmaptype == MAPTYPE_QUAKE3)
 						{
 							aasworld.numclusters = 0;
 							AAS_InitBotImport();
 							AAS_InitClustering();
 						} //end if
 					} //end if
 					else
 					{
 						Warning("AAS file %s not found in output folder\n", filename);
 						Log_Print("creating %s...\n", filename);
 						//set before map loading
 						create_aas = 1;
 						LoadMapFromBSP(qf);
 						//create the AAS file
 						AAS_Create(filename);
 						//if it's a Quake3 map calculate the reachabilities and clusters
 						if (loadedmaptype == MAPTYPE_QUAKE3) AAS_CalcReachAndClusters(qf);
 					} //end else
 					//
 					if (optimize) AAS_Optimize();
 					//write out the stored AAS file
 					if (!AAS_WriteAASFile(filename))
 					{
 						Error("error writing %s\n", filename);
 					} //end if
 					//deallocate memory
 					AAS_FreeMaxAAS();
 				} //end for
 				break;
 			} //end case
 			case COMP_AASOPTIMIZE:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					AASOuputFile(qf, outputpath, filename);
 					//
 					Log_Print("optimizing: %s to %s\n", qf->origname, filename);
 					if (qf->type != QFILETYPE_AAS) Warning("%s is probably not a AAS file\n", qf->origname);
 					//
 					AAS_InitBotImport();
 					//
 					if (!AAS_LoadAASFile(qf->filename, qf->offset, qf->length))
 					{
 						Error("error loading aas file %s\n", qf->filename);
 					} //end if
 					AAS_Optimize();
 					//write out the stored AAS file
 					if (!AAS_WriteAASFile(filename))
 					{
 						Error("error writing %s\n", filename);
 					} //end if
 					//deallocate memory
 					AAS_FreeMaxAAS();
 				} //end for
 				break;
 			} //end case
 			case COMP_AASINFO:
 			{
 				if (!qfiles) Log_Print("no files found\n");
 				for (qf = qfiles; qf; qf = qf->next)
 				{
 					AASOuputFile(qf, outputpath, filename);
 					//
 					Log_Print("aas info for: %s\n", filename);
 					if (qf->type != QFILETYPE_AAS) Warning("%s is probably not a AAS file\n", qf->origname);
 					//
 					AAS_InitBotImport();
 					//
 					if (!AAS_LoadAASFile(qf->filename, qf->offset, qf->length))
 					{
 						Error("error loading aas file %s\n", qf->filename);
 					} //end if
 					AAS_ShowTotals();
 				} //end for
 			} //end case
 			default:
 			{
 				Log_Print("don't know what to do\n");
 				break;
 			} //end default
 		} //end switch
 	} //end if
 	else
 	{
 		Log_Print("Usage:   bspc [-<switch> [-<switch> ...]]\n"
 #if defined(WIN32) || defined(_WIN32)
 			"Example 1: bspc -bsp2aas d:\\quake3\\baseq3\\maps\\mymap?.bsp\n"
 			"Example 2: bspc -bsp2aas d:\\quake3\\baseq3\\pak0.pk3\\maps/q3dm*.bsp\n"
 #else
 			"Example 1: bspc -bsp2aas /quake3/baseq3/maps/mymap?.bsp\n"
 			"Example 2: bspc -bsp2aas /quake3/baseq3/pak0.pk3/maps/q3dm*.bsp\n"
 #endif
 			"\n"
 			"Switches:\n"
 			//"   bsp2map  <[pakfilter/]filter.bsp>    = convert BSP to MAP\n"
 			//"   aasall   <quake3folder>              = create AAS files for all BSPs\n"
 			"   bsp2aas  <[pakfilter/]filter.bsp>    = convert BSP to AAS\n"
 			"   reach    <filter.bsp>                = compute reachability & clusters\n"
 			"   cluster  <filter.aas>                = compute clusters\n"
 			"   aasopt   <filter.aas>                = optimize aas file\n"
 			"   aasinfo  <filter.aas>                = show AAS file info\n"
 			"   output   <output path>               = set output path\n"
 			"   threads  <X>                         = set number of threads to X\n"
 			"   cfg      <filename>                  = use this cfg file\n"
 			"   optimize                             = enable optimization\n"
 			"   noverbose                            = disable verbose output\n"
 			"   breadthfirst                         = breadth first bsp building\n"
 			"   nobrushmerge                         = don't merge brushes\n"
 			"   noliquids                            = don't write liquids to map\n"
 			"   freetree                             = free the bsp tree\n"
 			"   nocsg                                = disables brush chopping\n"
 			"   forcesidesvisible                    = force all sides to be visible\n"
 			"   grapplereach                         = calculate grapple reachabilities\n"
 
 /*			"   glview     = output a GL view\n"
 			"   draw       = enables drawing\n"
 			"   noweld     = disables weld\n"
 			"   noshare    = disables sharing\n"
 			"   notjunc    = disables juncs\n"
 			"   nowater    = disables water brushes\n"
 			"   noprune    = disables node prunes\n"
 			"   nomerge    = disables face merging\n"
 			"   nosubdiv   = disables subdeviding\n"
 			"   nodetail   = disables detail brushes\n"
 			"   fulldetail = enables full detail\n"
 			"   onlyents   = only compile entities with bsp\n"
 			"   micro <volume>\n"
 			"              = sets the micro volume to the given float\n"
 			"   leaktest   = perform a leak test\n"
 			"   verboseentities\n"
 			"              = enable entity verbose mode\n"
 			"   chop <subdivide_size>\n"
 			"              = sets the subdivide size to the given float\n"*/
 			"\n");
 	} //end else
 	Log_Print("BSPC run time is %5.0f seconds\n", I_FloatTime() - start_time);
 	Log_Close();						//close the log file
 	return 0;
 } //end of the function main