Quake-III-Arena

map.c (35826B)

---

 /*
 ===========================================================================
 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
 ===========================================================================
 */
 
 #include "qbsp.h"
 #include "l_bsp_hl.h"
 #include "l_bsp_q1.h"
 #include "l_bsp_q2.h"
 #include "l_bsp_q3.h"
 #include "l_bsp_sin.h"
 #include "l_mem.h"
 #include "../botlib/aasfile.h"		//aas_bbox_t
 #include "aas_store.h"		//AAS_MAX_BBOXES
 #include "aas_cfg.h"
 
 #define Sign(x)		(x < 0 ? 1 : 0)
 
 int					nummapbrushes;
 mapbrush_t			mapbrushes[MAX_MAPFILE_BRUSHES];
 
 int					nummapbrushsides;
 side_t				brushsides[MAX_MAPFILE_BRUSHSIDES];
 brush_texture_t		side_brushtextures[MAX_MAPFILE_BRUSHSIDES];
 
 int					nummapplanes;
 plane_t				mapplanes[MAX_MAPFILE_PLANES];
 int					mapplaneusers[MAX_MAPFILE_PLANES];
 
 #define				PLANE_HASHES	1024
 plane_t				*planehash[PLANE_HASHES];
 vec3_t				map_mins, map_maxs;
 
 #ifdef SIN
 textureref_t		side_newrefs[MAX_MAPFILE_BRUSHSIDES];
 #endif
 
 map_texinfo_t		map_texinfo[MAX_MAPFILE_TEXINFO];
 int					map_numtexinfo;
 int					loadedmaptype;		//loaded map type
 
 // undefine to make plane finding use linear sort
 #define	USE_HASHING
 
 int c_boxbevels;
 int c_edgebevels;
 int c_areaportals;
 int c_clipbrushes;
 int c_squattbrushes;
 int c_writtenbrushes;
 
 /*
 =============================================================================
 
 PLANE FINDING
 
 =============================================================================
 */
 
 
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int PlaneSignBits(vec3_t normal)
 {
 	int i, signbits;
 
 	signbits = 0;
 	for (i = 2; i >= 0; i--)
 	{
 		signbits = (signbits << 1) + Sign(normal[i]);
 	} //end for
 	return signbits;
 } //end of the function PlaneSignBits
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int PlaneTypeForNormal(vec3_t normal)
 {
 	vec_t	ax, ay, az;
 	
 // NOTE: should these have an epsilon around 1.0?		
 	if (normal[0] == 1.0 || normal[0] == -1.0)
 		return PLANE_X;
 	if (normal[1] == 1.0 || normal[1] == -1.0)
 		return PLANE_Y;
 	if (normal[2] == 1.0 || normal[2] == -1.0)
 		return PLANE_Z;
 		
 	ax = fabs(normal[0]);
 	ay = fabs(normal[1]);
 	az = fabs(normal[2]);
 	
 	if (ax >= ay && ax >= az)
 		return PLANE_ANYX;
 	if (ay >= ax && ay >= az)
 		return PLANE_ANYY;
 	return PLANE_ANYZ;
 } //end of the function PlaneTypeForNormal
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 //ME NOTE: changed from 0.00001
 #define	NORMAL_EPSILON	0.0001
 //ME NOTE: changed from 0.01
 #define	DIST_EPSILON	0.02
 qboolean	PlaneEqual(plane_t *p, vec3_t normal, vec_t dist)
 {
 #if 1
 	if (
 	   fabs(p->normal[0] - normal[0]) < NORMAL_EPSILON
 	&& fabs(p->normal[1] - normal[1]) < NORMAL_EPSILON
 	&& fabs(p->normal[2] - normal[2]) < NORMAL_EPSILON
 	&& fabs(p->dist - dist) < DIST_EPSILON )
 		return true;
 #else
 	if (p->normal[0] == normal[0]
 		&& p->normal[1] == normal[1]
 		&& p->normal[2] == normal[2]
 		&& p->dist == dist)
 		return true;
 #endif
 	return false;
 } //end of the function PlaneEqual
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AddPlaneToHash(plane_t *p)
 {
 	int		hash;
 
 	hash = (int)fabs(p->dist) / 8;
 	hash &= (PLANE_HASHES-1);
 
 	p->hash_chain = planehash[hash];
 	planehash[hash] = p;
 } //end of the function AddPlaneToHash
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int CreateNewFloatPlane (vec3_t normal, vec_t dist)
 {
 	plane_t	*p, temp;
 
 	if (VectorLength(normal) < 0.5)
 		Error ("FloatPlane: bad normal");
 	// create a new plane
 	if (nummapplanes+2 > MAX_MAPFILE_PLANES)
 		Error ("MAX_MAPFILE_PLANES");
 
 	p = &mapplanes[nummapplanes];
 	VectorCopy (normal, p->normal);
 	p->dist = dist;
 	p->type = (p+1)->type = PlaneTypeForNormal (p->normal);
 	p->signbits = PlaneSignBits(p->normal);
 
 	VectorSubtract (vec3_origin, normal, (p+1)->normal);
 	(p+1)->dist = -dist;
 	(p+1)->signbits = PlaneSignBits((p+1)->normal);
 
 	nummapplanes += 2;
 
 	// allways put axial planes facing positive first
 	if (p->type < 3)
 	{
 		if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)
 		{
 			// flip order
 			temp = *p;
 			*p = *(p+1);
 			*(p+1) = temp;
 
 			AddPlaneToHash (p);
 			AddPlaneToHash (p+1);
 			return nummapplanes - 1;
 		}
 	}
 
 	AddPlaneToHash (p);
 	AddPlaneToHash (p+1);
 	return nummapplanes - 2;
 } //end of the function CreateNewFloatPlane
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void SnapVector(vec3_t normal)
 {
 	int		i;
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if ( fabs(normal[i] - 1) < NORMAL_EPSILON )
 		{
 			VectorClear (normal);
 			normal[i] = 1;
 			break;
 		}
 		if ( fabs(normal[i] - -1) < NORMAL_EPSILON )
 		{
 			VectorClear (normal);
 			normal[i] = -1;
 			break;
 		}
 	}
 } //end of the function SnapVector
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void SnapPlane(vec3_t normal, vec_t *dist)
 {
 	SnapVector(normal);
 
 	if (fabs(*dist-Q_rint(*dist)) < DIST_EPSILON)
 		*dist = Q_rint(*dist);
 } //end of the function SnapPlane
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 #ifndef USE_HASHING
 int FindFloatPlane(vec3_t normal, vec_t dist)
 {
 	int i;
 	plane_t *p;
 
 	SnapPlane(normal, &dist);
 	for (i = 0, p = mapplanes; i < nummapplanes; i++, p++)
 	{
 		if (PlaneEqual (p, normal, dist))
 		{
 			mapplaneusers[i]++;
 			return i;
 		} //end if
 	} //end for
 	i = CreateNewFloatPlane (normal, dist);
 	mapplaneusers[i]++;
 	return i;
 } //end of the function FindFloatPlane
 #else
 int FindFloatPlane (vec3_t normal, vec_t dist)
 {
 	int i;
 	plane_t *p;
 	int hash, h;
 
 	SnapPlane (normal, &dist);
 	hash = (int)fabs(dist) / 8;
 	hash &= (PLANE_HASHES-1);
 
 	// search the border bins as well
 	for (i = -1; i <= 1; i++)
 	{
 		h = (hash+i)&(PLANE_HASHES-1);
 		for (p = planehash[h]; p; p = p->hash_chain)
 		{
 			if (PlaneEqual(p, normal, dist))
 			{
 				mapplaneusers[p-mapplanes]++;
 				return p - mapplanes;
 			} //end if
 		} //end for
 	} //end for
 	i = CreateNewFloatPlane (normal, dist);
 	mapplaneusers[i]++;
 	return i;
 } //end of the function FindFloatPlane
 #endif
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int PlaneFromPoints (int *p0, int *p1, int *p2)
 {
 	vec3_t	t1, t2, normal;
 	vec_t	dist;
 
 	VectorSubtract (p0, p1, t1);
 	VectorSubtract (p2, p1, t2);
 	CrossProduct (t1, t2, normal);
 	VectorNormalize (normal);
 
 	dist = DotProduct (p0, normal);
 
 	return FindFloatPlane (normal, dist);
 } //end of the function PlaneFromPoints
 //===========================================================================
 // Adds any additional planes necessary to allow the brush to be expanded
 // against axial bounding boxes
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AddBrushBevels (mapbrush_t *b)
 {
 	int		axis, dir;
 	int		i, j, k, l, order;
 	side_t	sidetemp;
 	brush_texture_t	tdtemp;
 #ifdef SIN
    textureref_t trtemp;
 #endif
 	side_t	*s, *s2;
 	vec3_t	normal;
 	float	dist;
 	winding_t	*w, *w2;
 	vec3_t	vec, vec2;
 	float	d;
 
 	//
 	// add the axial planes
 	//
 	order = 0;
 	for (axis=0 ; axis <3 ; axis++)
 	{
 		for (dir=-1 ; dir <= 1 ; dir+=2, order++)
 		{
 			// see if the plane is allready present
 			for (i=0, s=b->original_sides ; i<b->numsides ; i++,s++)
 			{
 				if (mapplanes[s->planenum].normal[axis] == dir)
 					break;
 			}
 
 			if (i == b->numsides)
 			{	// add a new side
 				if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
 					Error ("MAX_MAP_BRUSHSIDES");
 				nummapbrushsides++;
 				b->numsides++;
 				VectorClear (normal);
 				normal[axis] = dir;
 				if (dir == 1)
 					dist = b->maxs[axis];
 				else
 					dist = -b->mins[axis];
 				s->planenum = FindFloatPlane (normal, dist);
 				s->texinfo = b->original_sides[0].texinfo;
 #ifdef SIN
 				s->lightinfo = b->original_sides[0].lightinfo;
 #endif
 				s->contents = b->original_sides[0].contents;
 				s->flags |= SFL_BEVEL;
 				c_boxbevels++;
 			}
 
 			// if the plane is not in it canonical order, swap it
 			if (i != order)
 			{
 				sidetemp = b->original_sides[order];
 				b->original_sides[order] = b->original_sides[i];
 				b->original_sides[i] = sidetemp;
 
 				j = b->original_sides - brushsides;
 				tdtemp = side_brushtextures[j+order];
 				side_brushtextures[j+order] = side_brushtextures[j+i];
 				side_brushtextures[j+i] = tdtemp;
 
 #ifdef SIN
 				trtemp = side_newrefs[j+order];
 				side_newrefs[j+order] = side_newrefs[j+i];
 				side_newrefs[j+i] = trtemp;
 #endif
 			}
 		}
 	}
 
 	//
 	// add the edge bevels
 	//
 	if (b->numsides == 6)
 		return;		// pure axial
 
 	// test the non-axial plane edges
 	for (i=6 ; i<b->numsides ; i++)
 	{
 		s = b->original_sides + i;
 		w = s->winding;
 		if (!w)
 			continue;
 		for (j=0 ; j<w->numpoints ; j++)
 		{
 			k = (j+1)%w->numpoints;
 			VectorSubtract (w->p[j], w->p[k], vec);
 			if (VectorNormalize (vec) < 0.5)
 				continue;
 			SnapVector (vec);
 			for (k=0 ; k<3 ; k++)
 				if ( vec[k] == -1 || vec[k] == 1)
 					break;	// axial
 			if (k != 3)
 				continue;	// only test non-axial edges
 
 			// try the six possible slanted axials from this edge
 			for (axis=0 ; axis <3 ; axis++)
 			{
 				for (dir=-1 ; dir <= 1 ; dir+=2)
 				{
 					// construct a plane
 					VectorClear (vec2);
 					vec2[axis] = dir;
 					CrossProduct (vec, vec2, normal);
 					if (VectorNormalize (normal) < 0.5)
 						continue;
 					dist = DotProduct (w->p[j], normal);
 
 					// if all the points on all the sides are
 					// behind this plane, it is a proper edge bevel
 					for (k=0 ; k<b->numsides ; k++)
 					{
 						// if this plane has allready been used, skip it
 						if (PlaneEqual (&mapplanes[b->original_sides[k].planenum]
 							, normal, dist) )
 							break;
 
 						w2 = b->original_sides[k].winding;
 						if (!w2)
 							continue;
 						for (l=0 ; l<w2->numpoints ; l++)
 						{
 							d = DotProduct (w2->p[l], normal) - dist;
 							if (d > 0.1)
 								break;	// point in front
 						}
 						if (l != w2->numpoints)
 							break;
 					}
 
 					if (k != b->numsides)
 						continue;	// wasn't part of the outer hull
 					// add this plane
 					if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
 						Error ("MAX_MAP_BRUSHSIDES");
 					nummapbrushsides++;
 					s2 = &b->original_sides[b->numsides];
 					s2->planenum = FindFloatPlane (normal, dist);
 					s2->texinfo = b->original_sides[0].texinfo;
 #ifdef SIN
 					s2->lightinfo = b->original_sides[0].lightinfo;
 #endif
 					s2->contents = b->original_sides[0].contents;
 					s2->flags |= SFL_BEVEL;
 					c_edgebevels++;
 					b->numsides++;
 				}
 			}
 		}
 	}
 } //end of the function AddBrushBevels
 //===========================================================================
 // creates windigs for sides and mins / maxs for the brush
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean MakeBrushWindings(mapbrush_t *ob)
 {
 	int			i, j;
 	winding_t	*w;
 	side_t		*side;
 	plane_t		*plane;
 
 	ClearBounds (ob->mins, ob->maxs);
 
 	for (i = 0; i < ob->numsides; i++)
 	{
 		plane = &mapplanes[ob->original_sides[i].planenum];
 		w = BaseWindingForPlane(plane->normal, plane->dist);
 		for (j = 0; j <ob->numsides && w; j++)
 		{
 			if (i == j) continue;
 			if (ob->original_sides[j].flags & SFL_BEVEL) continue;
 			plane = &mapplanes[ob->original_sides[j].planenum^1];
 			ChopWindingInPlace(&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);
 		}
 
 		side = &ob->original_sides[i];
 		side->winding = w;
 		if (w)
 		{
 			side->flags |= SFL_VISIBLE;
 			for (j = 0; j < w->numpoints; j++)
 				AddPointToBounds (w->p[j], ob->mins, ob->maxs);
 		}
 	}
 
 	for (i = 0; i < 3; i++)
 	{
 		//IDBUG: all the indexes into the mins and maxs were zero (not using i)
 		if (ob->mins[i] < -MAX_MAP_BOUNDS || ob->maxs[i] > MAX_MAP_BOUNDS)
 		{
 			Log_Print("entity %i, brush %i: bounds out of range\n", ob->entitynum, ob->brushnum);
 			ob->numsides = 0; //remove the brush
 			break;
 		} //end if
 		if (ob->mins[i] > MAX_MAP_BOUNDS || ob->maxs[i] < -MAX_MAP_BOUNDS)
 		{
 			Log_Print("entity %i, brush %i: no visible sides on brush\n", ob->entitynum, ob->brushnum);
 			ob->numsides = 0; //remove the brush
 			break;
 		} //end if
 	} //end for
 	return true;
 } //end of the function MakeBrushWindings
 //===========================================================================
 // FIXME: currently doesn't mark all bevels
 // NOTE: when one brush bevel is found the remaining sides of the brush
 //       are bevels as well (when the brush isn't expanded for AAS :))
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void MarkBrushBevels(mapbrush_t *brush)
 {
 	int i;
 	int we;
 	side_t *s;
 
 	//check all the sides of the brush
 	for (i = 0; i < brush->numsides; i++)
 	{
 		s = brush->original_sides + i;
 		//if the side has no winding
 		if (!s->winding)
 		{
 			Log_Write("MarkBrushBevels: brush %d no winding", brush->brushnum);
 			s->flags |= SFL_BEVEL;
 		} //end if
 		//if the winding is tiny
 		else if (WindingIsTiny(s->winding))
 		{
 			s->flags |= SFL_BEVEL;
 			Log_Write("MarkBrushBevels: brush %d tiny winding", brush->brushnum);
 		} //end else if
 		//if the winding has errors
 		else
 		{
 			we = WindingError(s->winding);
 			if (we == WE_NOTENOUGHPOINTS
 					|| we == WE_SMALLAREA
 					|| we == WE_POINTBOGUSRANGE
 //					|| we == WE_NONCONVEX
 					)
 			{
 				Log_Write("MarkBrushBevels: brush %d %s", brush->brushnum, WindingErrorString());
 				s->flags |= SFL_BEVEL;
 			} //end else if
 		} //end else
 		if (s->flags & SFL_BEVEL)
 		{
 			s->flags &= ~SFL_VISIBLE;
 			//if the side has a valid plane
 			if (s->planenum > 0 && s->planenum < nummapplanes)
 			{
 				//if it is an axial plane
 				if (mapplanes[s->planenum].type < 3) c_boxbevels++;
 				else c_edgebevels++;
 			} //end if
 		} //end if
 	} //end for
 } //end of the function MarkBrushBevels
 //===========================================================================
 // returns true if the map brush already exists
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int BrushExists(mapbrush_t *brush)
 {
 	int i, s1, s2;
 	side_t *side1, *side2;
 	mapbrush_t *brush1, *brush2;
 
 	for (i = 0; i < nummapbrushes; i++)
 	{
 		brush1 = brush;
 		brush2 = &mapbrushes[i];
 		//compare the brushes
 		if (brush1->entitynum != brush2->entitynum) continue;
 		//if (brush1->contents != brush2->contents) continue;
 		if (brush1->numsides != brush2->numsides) continue;
 		for (s1 = 0; s1 < brush1->numsides; s1++)
 		{
 			side1 = brush1->original_sides + s1;
 			//
 			for (s2 = 0; s2 < brush2->numsides; s2++)
 			{
 				side2 = brush2->original_sides + s2;
 				//
 				if ((side1->planenum & ~1) == (side2->planenum & ~1)
 //						&& side1->texinfo == side2->texinfo
 //						&& side1->contents == side2->contents
 //						&& side1->surf == side2->surf
 					) break;
 			} //end if
 			if (s2 >= brush2->numsides) break;
 		} //end for
 		if (s1 >= brush1->numsides) return true;
 	} //end for
 	return false;
 } //end of the function BrushExists
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean WriteMapBrush(FILE *fp, mapbrush_t *brush, vec3_t origin)
 {
 	int sn, rotate, shift[2], sv, tv, planenum, p1, i, j;
 	float scale[2], originshift[2], ang1, ang2, newdist;
 	vec3_t vecs[2], axis[2];
 	map_texinfo_t *ti;
 	winding_t *w;
 	side_t *s;
 	plane_t *plane;
 
 	if (noliquids)
 	{
 		if (brush->contents & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA))
 		{
 			return true;
 		} //end if
 	} //end if
 	//if the brush has no contents
 	if (!brush->contents) return true;
 	//print the leading {
 	if (fprintf(fp, " { //brush %d\n", brush->brushnum) < 0) return false;
 	//write brush sides
 	for (sn = 0; sn < brush->numsides; sn++)
 	{
 		s = brush->original_sides + sn;
 		//don't write out bevels
 		if (!(s->flags & SFL_BEVEL))
 		{
 			//if the entity has an origin set
 			if (origin[0] || origin[1] || origin[2])
 			{
 				newdist = mapplanes[s->planenum].dist +
 					DotProduct(mapplanes[s->planenum].normal, origin);
 				planenum = FindFloatPlane(mapplanes[s->planenum].normal, newdist);
 			} //end if
 			else
 			{
 				planenum = s->planenum;
 			} //end else
 			//always take the first plane, then flip the points if necesary
 			plane = &mapplanes[planenum & ~1];
 			w = BaseWindingForPlane(plane->normal, plane->dist);
 			//
 			for (i = 0; i < 3; i++)
 			{
 				for (j = 0; j < 3; j++)
 				{
 					if (fabs(w->p[i][j]) < 0.2) w->p[i][j] = 0;
 					else if (fabs((int)w->p[i][j] - w->p[i][j]) < 0.3) w->p[i][j] = (int) w->p[i][j];
 					//w->p[i][j] = (int) (w->p[i][j] + 0.2);
 				} //end for
 			} //end for
 			//three non-colinear points to define the plane
 			if (planenum & 1) p1 = 1;
 			else p1 = 0;
 			if (fprintf(fp,"  ( %5i %5i %5i ) ", (int)w->p[p1][0], (int)w->p[p1][1], (int)w->p[p1][2]) < 0) return false;
 			if (fprintf(fp,"( %5i %5i %5i ) ", (int)w->p[!p1][0], (int)w->p[!p1][1], (int)w->p[!p1][2]) < 0) return false;
 			if (fprintf(fp,"( %5i %5i %5i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]) < 0) return false;
 			//free the winding
 			FreeWinding(w);
 			//
 			if (s->texinfo == TEXINFO_NODE)
 			{
 				if (brush->contents & CONTENTS_PLAYERCLIP)
 				{
 					//player clip
 					if (loadedmaptype == MAPTYPE_SIN)
 					{
 						if (fprintf(fp, "generic/misc/clip 0 0 0 1 1") < 0) return false;
 					} //end if
 					else if (loadedmaptype == MAPTYPE_QUAKE2)
 					{	//FIXME: don't always use e1u1
 						if (fprintf(fp, "e1u1/clip 0 0 0 1 1") < 0) return false;
 					} //end else
 					else if (loadedmaptype == MAPTYPE_QUAKE3)
 					{
 						if (fprintf(fp, "e1u1/clip 0 0 0 1 1") < 0) return false;
 					} //end else if
 					else
 					{
 						if (fprintf(fp, "clip 0 0 0 1 1") < 0) return false;
 					} //end else
 				} //end if
 				else if (brush->contents == CONTENTS_MONSTERCLIP)
 				{
 					//monster clip
 					if (loadedmaptype == MAPTYPE_SIN)
 					{
 						if (fprintf(fp, "generic/misc/monster 0 0 0 1 1") < 0) return false;
 					} //end if
 					else if (loadedmaptype == MAPTYPE_QUAKE2)
 					{
 						if (fprintf(fp, "e1u1/clip_mon 0 0 0 1 1") < 0) return false;
 					} //end else
 					else
 					{
 						if (fprintf(fp, "clip 0 0 0 1 1") < 0) return false;
 					} //end else
 				} //end else
 				else
 				{
 					if (fprintf(fp, "clip 0 0 0 1 1") < 0) return false;
 					Log_Write("brush->contents = %d\n", brush->contents);
 				} //end else
 			} //end if
 			else if (loadedmaptype == MAPTYPE_SIN && s->texinfo == 0)
 			{
 				if (brush->contents & CONTENTS_DUMMYFENCE)
 				{
 					if (fprintf(fp, "generic/misc/fence 0 0 0 1 1") < 0) return false;
 				} //end if
 				else if (brush->contents & CONTENTS_MIST)
 				{
 					if (fprintf(fp, "generic/misc/volumetric_base 0 0 0 1 1") < 0) return false;
 				} //end if
 				else //unknown so far
 				{
 					if (fprintf(fp, "generic/misc/red 0 0 0 1 1") < 0) return false;
 				} //end else
 			} //end if
 			else if (loadedmaptype == MAPTYPE_QUAKE3)
 			{
 				//always use the same texture
 				if (fprintf(fp, "e2u3/floor1_2 0 0 0 1 1 1 0 0") < 0) return false;
 			} //end else if
 			else
 			{
 				//*
 				ti = &map_texinfo[s->texinfo];
 				//the scaling of the texture
 				scale[0] = 1 / VectorNormalize2(ti->vecs[0], vecs[0]);
 				scale[1] = 1 / VectorNormalize2(ti->vecs[1], vecs[1]);
 				//
 				TextureAxisFromPlane(plane, axis[0], axis[1]);
 				//calculate texture shift done by entity origin
 				originshift[0] = DotProduct(origin, axis[0]);
 				originshift[1] = DotProduct(origin, axis[1]);
 				//the texture shift without origin shift
 				shift[0] = ti->vecs[0][3] - originshift[0];
 				shift[1] = ti->vecs[1][3] - originshift[1];
 				//
 				if (axis[0][0]) sv = 0;
 				else if (axis[0][1]) sv = 1;
 				else sv = 2;
 				if (axis[1][0]) tv = 0;
 				else if (axis[1][1]) tv = 1;
 				else tv = 2;
 				//calculate rotation of texture
 				if (vecs[0][tv] == 0) ang1 = vecs[0][sv] > 0 ? 90.0 : -90.0;
 				else ang1 = atan2(vecs[0][sv], vecs[0][tv]) * 180 / Q_PI;
 				if (ang1 < 0) ang1 += 360;
 				if (ang1 >= 360) ang1 -= 360;
 				if (axis[0][tv] == 0) ang2 = axis[0][sv] > 0 ? 90.0 : -90.0;
 				else ang2 = atan2(axis[0][sv], axis[0][tv]) * 180 / Q_PI;
 				if (ang2 < 0) ang2 += 360;
 				if (ang2 >= 360) ang2 -= 360;
 				rotate = ang2 - ang1;
 				if (rotate < 0) rotate += 360;
 				if (rotate >= 360) rotate -= 360;
 				//write the texture info
 				if (fprintf(fp, "%s %d %d %d", ti->texture, shift[0], shift[1], rotate) < 0) return false;
 				if (fabs(scale[0] - ((int) scale[0])) < 0.001)
 				{
 					if (fprintf(fp, " %d", (int) scale[0]) < 0) return false;
 				} //end if
 				else
 				{
 					if (fprintf(fp, " %4f", scale[0]) < 0) return false;
 				} //end if
 				if (fabs(scale[1] - ((int) scale[1])) < 0.001)
 				{
 					if (fprintf(fp, " %d", (int) scale[1]) < 0) return false;
 				} //end if
 				else
 				{
 					if (fprintf(fp, " %4f", scale[1]) < 0) return false;
 				} //end else
 				//write the extra brush side info
 				if (loadedmaptype == MAPTYPE_QUAKE2)
 				{
 					if (fprintf(fp, " %ld %ld %ld", s->contents, ti->flags, ti->value) < 0) return false;
 				} //end if
 				//*/
 			} //end else
 			if (fprintf(fp, "\n") < 0) return false;
 		} //end if
 	} //end if
 	if (fprintf(fp, " }\n") < 0) return false;
 	c_writtenbrushes++;
 	return true;
 } //end of the function WriteMapBrush
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean WriteOriginBrush(FILE *fp, vec3_t origin)
 {
 	vec3_t normal;
 	float dist;
 	int i, s;
 	winding_t *w;
 
 	if (fprintf(fp, " {\n") < 0) return false;
 	//
 	for (i = 0; i < 3; i++)
 	{
 		for (s = -1; s <= 1; s += 2)
 		{
 			//
 			VectorClear(normal);
 			normal[i] = s;
 			dist = origin[i] * s + 16;
 			//
 			w = BaseWindingForPlane(normal, dist);
 			//three non-colinear points to define the plane
 			if (fprintf(fp,"  ( %5i %5i %5i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2]) < 0) return false;
 			if (fprintf(fp,"( %5i %5i %5i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2]) < 0) return false;
 			if (fprintf(fp,"( %5i %5i %5i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]) < 0) return false;
 			//free the winding
 			FreeWinding(w);
 			//write origin texture:
 			// CONTENTS_ORIGIN = 16777216
 			// SURF_NODRAW = 128
 			if (loadedmaptype == MAPTYPE_SIN)
 			{
 				if (fprintf(fp, "generic/misc/origin 0 0 0 1 1") < 0) return false;
 			} //end if
 			else if (loadedmaptype == MAPTYPE_HALFLIFE)
 			{
 				if (fprintf(fp, "origin 0 0 0 1 1") < 0) return false;
 			} //end if
 			else
 			{
 				if (fprintf(fp, "e1u1/origin 0 0 0 1 1") < 0) return false;
 			} //end else
 			//Quake2 extra brush side info
 			if (loadedmaptype == MAPTYPE_QUAKE2)
 			{
 				//if (fprintf(fp, " 16777216 128 0") < 0) return false;
 			} //end if
 			if (fprintf(fp, "\n") < 0) return false;
 		} //end for
 	} //end for
 	if (fprintf(fp, " }\n") < 0) return false;
 	c_writtenbrushes++;
 	return true;
 } //end of the function WriteOriginBrush
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 mapbrush_t *GetAreaPortalBrush(entity_t *mapent)
 {
 	int portalnum, bn;
 	mapbrush_t *brush;
 
 	//the area portal number
 	portalnum = mapent->areaportalnum;
 	//find the area portal brush in the world brushes
 	for (bn = 0; bn < nummapbrushes && portalnum; bn++)
 	{
 		brush = &mapbrushes[bn];
 		//must be in world entity
 		if (brush->entitynum == 0)
 		{
 			if (brush->contents & CONTENTS_AREAPORTAL)
 			{
 				portalnum--;
 			} //end if
 		} //end if
 	} //end for
 	if (bn < nummapbrushes)
 	{
 		return brush;
 	} //end if
 	else
 	{
 		Log_Print("area portal %d brush not found\n", mapent->areaportalnum);
 		return NULL;
 	} //end else
 } //end of the function GetAreaPortalBrush
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean WriteMapFileSafe(FILE *fp)
 {
 	char key[1024], value[1024];
 	int i, bn, entitybrushes;
 	epair_t *ep;
 	mapbrush_t *brush;
 	entity_t *mapent;
 	//vec3_t vec_origin = {0, 0, 0};
 
 	//
 	if (fprintf(fp,"//=====================================================\n"
 			"//\n"
 			"// map file created with BSPC "BSPC_VERSION"\n"
 			"//\n"
 			"// BSPC is designed to decompile material in which you own the copyright\n"
 			"// or have obtained permission to decompile from the copyright owner. Unless\n"
 			"// you own the copyright or have permission to decompile from the copyright\n"
 			"// owner, you may be violating copyright law and be subject to payment of\n"
 			"// damages and other remedies. If you are uncertain about your rights, contact\n"
 			"// your legal advisor.\n"
 			"//\n") < 0) return false;
 	if (loadedmaptype == MAPTYPE_SIN)
 	{
 		if (fprintf(fp,
 						"// generic/misc/red is used for unknown textures\n") < 0) return false;
 	} //end if
 	if (fprintf(fp,"//\n"
 						"//=====================================================\n") < 0) return false;
 	//write out all the entities
 	for (i = 0; i < num_entities; i++)
 	{
 		mapent = &entities[i];
 		if (!mapent->epairs)
 		{
 			continue;
 		} //end if
 		if (fprintf(fp, "{\n") < 0) return false;
 		//
 		if (loadedmaptype == MAPTYPE_QUAKE3)
 		{
 			if (!stricmp(ValueForKey(mapent, "classname"), "light"))
 			{
 				SetKeyValue(mapent, "light", "10000");
 			} //end if
 		} //end if
 		//write epairs
 		for (ep = mapent->epairs; ep; ep = ep->next)
 		{
 			strcpy(key, ep->key);
 			StripTrailing (key);
 			strcpy(value, ep->value);
 			StripTrailing(value);
 			//
 			if (loadedmaptype == MAPTYPE_QUAKE2 ||
 					loadedmaptype == MAPTYPE_SIN)
 			{
 				//don't write an origin for BSP models
 				if (mapent->modelnum >= 0 && !strcmp(key, "origin")) continue;
 			} //end if
 			//don't write BSP model numbers
 			if (mapent->modelnum >= 0 && !strcmp(key, "model") && value[0] == '*') continue;
 			//
 			if (fprintf(fp, " \"%s\" \"%s\"\n", key, value) < 0) return false;
 		} //end for
 		//
 		if (ValueForKey(mapent, "origin")) GetVectorForKey(mapent, "origin", mapent->origin);
 		else mapent->origin[0] = mapent->origin[1] = mapent->origin[2] = 0;
 		//if this is an area portal entity
 		if (!strcmp("func_areaportal", ValueForKey(mapent, "classname")))
 		{
 			brush = GetAreaPortalBrush(mapent);
 			if (!brush) return false;
 			if (!WriteMapBrush(fp, brush, mapent->origin)) return false;
 		} //end if
 		else
 		{
 			entitybrushes = false;
 			//write brushes
 			for (bn = 0; bn < nummapbrushes; bn++)
 			{
 				brush = &mapbrushes[bn];
 				//if the brush is part of this entity
 				if (brush->entitynum == i)
 				{
 					//don't write out area portal brushes in the world
 					if (!((brush->contents & CONTENTS_AREAPORTAL) && brush->entitynum == 0))
 					{
 						/*
 						if (!strcmp("func_door_rotating", ValueForKey(mapent, "classname")))
 						{
 							AAS_PositionFuncRotatingBrush(mapent, brush);
 							if (!WriteMapBrush(fp, brush, vec_origin)) return false;
 						} //end if
 						else //*/
 						{
 							if (!WriteMapBrush(fp, brush, mapent->origin)) return false;
 						} //end else
 						entitybrushes = true;
 					} //end if
 				} //end if
 			} //end for
 			//if the entity had brushes
 			if (entitybrushes)
 			{
 				//if the entity has an origin set
 				if (mapent->origin[0] || mapent->origin[1] || mapent->origin[2])
 				{
 					if (!WriteOriginBrush(fp, mapent->origin)) return false;
 				} //end if
 			} //end if
 		} //end else
 		if (fprintf(fp, "}\n") < 0) return false;
 	} //end for
 	if (fprintf(fp, "//total of %d brushes\n", c_writtenbrushes) < 0) return false;
 	return true;
 } //end of the function WriteMapFileSafe
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void WriteMapFile(char *filename)
 {
 	FILE *fp;
 	double start_time;
 
 	c_writtenbrushes = 0;
 	//the time started
 	start_time = I_FloatTime();
 	//
 	Log_Print("writing %s\n", filename);
 	fp = fopen(filename, "wb");
 	if (!fp)
 	{
 		Log_Print("can't open %s\n", filename);
 		return;
 	} //end if
 	if (!WriteMapFileSafe(fp))
 	{
 		fclose(fp);
 		Log_Print("error writing map file %s\n", filename);
 		return;
 	} //end if
 	fclose(fp);
 	//display creation time
 	Log_Print("written %d brushes\n", c_writtenbrushes);
 	Log_Print("map file written in %5.0f seconds\n", I_FloatTime() - start_time);
 } //end of the function WriteMapFile
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void PrintMapInfo(void)
 {
 	Log_Print("\n");
 	Log_Print("%6i brushes\n", nummapbrushes);
 	Log_Print("%6i brush sides\n", nummapbrushsides);
 //	Log_Print("%6i clipbrushes\n", c_clipbrushes);
 //	Log_Print("%6i total sides\n", nummapbrushsides);
 //	Log_Print("%6i boxbevels\n", c_boxbevels);
 //	Log_Print("%6i edgebevels\n", c_edgebevels);
 //	Log_Print("%6i entities\n", num_entities);
 //	Log_Print("%6i planes\n", nummapplanes);
 //	Log_Print("%6i areaportals\n", c_areaportals);
 //	Log_Print("%6i squatt brushes\n", c_squattbrushes);
 //	Log_Print("size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", map_mins[0],map_mins[1],map_mins[2],
 //		map_maxs[0],map_maxs[1],map_maxs[2]);
 } //end of the function PrintMapInfo
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void ResetMapLoading(void)
 {
 	int i;
 	epair_t *ep, *nextep;
 
 	Q2_ResetMapLoading();
 	Sin_ResetMapLoading();
 
 	//free all map brush side windings
 	for (i = 0; i < nummapbrushsides; i++)
 	{
 		if (brushsides[i].winding)
 		{
 			FreeWinding(brushsides[i].winding);
 		} //end for
 	} //end for
 
 	//reset regular stuff
 	nummapbrushes = 0;
 	memset(mapbrushes, 0, MAX_MAPFILE_BRUSHES * sizeof(mapbrush_t));
 	//
 	nummapbrushsides = 0;
 	memset(brushsides, 0, MAX_MAPFILE_BRUSHSIDES * sizeof(side_t));
 	memset(side_brushtextures, 0, MAX_MAPFILE_BRUSHSIDES * sizeof(brush_texture_t));
 	//
 	nummapplanes = 0;
 	memset(mapplanes, 0, MAX_MAPFILE_PLANES * sizeof(plane_t));
 	//
 	memset(planehash, 0, PLANE_HASHES * sizeof(plane_t *));
 	//
 	memset(map_texinfo, 0, MAX_MAPFILE_TEXINFO * sizeof(map_texinfo_t));
 	map_numtexinfo = 0;
 	//
 	VectorClear(map_mins);
 	VectorClear(map_maxs);
 	//
 	c_boxbevels = 0;
 	c_edgebevels = 0;
 	c_areaportals = 0;
 	c_clipbrushes = 0;
 	c_writtenbrushes = 0;
 	//clear the entities
 	for (i = 0; i < num_entities; i++)
 	{
 		for (ep = entities[i].epairs; ep; ep = nextep)
 		{
 			nextep = ep->next;
 			FreeMemory(ep->key);
 			FreeMemory(ep->value);
 			FreeMemory(ep);
 		} //end for
 	} //end for
 	num_entities = 0;
 	memset(entities, 0, MAX_MAP_ENTITIES * sizeof(entity_t));
 } //end of the function ResetMapLoading
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 #ifndef Q1_BSPVERSION
 #define Q1_BSPVERSION	29
 #endif
 #ifndef HL_BSPVERSION
 #define HL_BSPVERSION	30
 #endif
 
 #define Q2_BSPHEADER				(('P'<<24)+('S'<<16)+('B'<<8)+'I')	//IBSP
 #define Q2_BSPVERSION	38
 
 #define SINGAME_BSPHEADER		(('P'<<24)+('S'<<16)+('B'<<8)+'R')	//RBSP
 #define SINGAME_BSPVERSION		1
 
 #define SIN_BSPHEADER			(('P'<<24)+('S'<<16)+('B'<<8)+'I')	//IBSP
 #define SIN_BSPVERSION	41
 
 typedef struct
 {
 	int ident;
 	int version;
 } idheader_t;
 
 int LoadMapFromBSP(struct quakefile_s *qf)
 {
 	idheader_t idheader;
 
 	if (ReadQuakeFile(qf, &idheader, 0, sizeof(idheader_t)) != sizeof(idheader_t))
 	{
 		return false;
 	} //end if
 
 	idheader.ident = LittleLong(idheader.ident);
 	idheader.version = LittleLong(idheader.version);
 	//Quake3 BSP file
 	if (idheader.ident == Q3_BSP_IDENT && idheader.version == Q3_BSP_VERSION)
 	{
 		ResetMapLoading();
 		Q3_LoadMapFromBSP(qf);
 		Q3_FreeMaxBSP();
 	} //end if
 	//Quake2 BSP file
 	else if (idheader.ident == Q2_BSPHEADER && idheader.version == Q2_BSPVERSION)
 	{
 		ResetMapLoading();
 		Q2_AllocMaxBSP();
 		Q2_LoadMapFromBSP(qf->filename, qf->offset, qf->length);
 		Q2_FreeMaxBSP();
 	} //endif
 	//Sin BSP file
 	else if ((idheader.ident == SIN_BSPHEADER && idheader.version == SIN_BSPVERSION) ||
 				//the dorks gave the same format another ident and verions
 				(idheader.ident == SINGAME_BSPHEADER && idheader.version == SINGAME_BSPVERSION))
 	{
 		ResetMapLoading();
 		Sin_AllocMaxBSP();
 		Sin_LoadMapFromBSP(qf->filename, qf->offset, qf->length);
 		Sin_FreeMaxBSP();
 	} //end if
 	//the Quake1 bsp files don't have a ident only a version
 	else if (idheader.ident == Q1_BSPVERSION)
 	{
 		ResetMapLoading();
 		Q1_AllocMaxBSP();
 		Q1_LoadMapFromBSP(qf->filename, qf->offset, qf->length);
 		Q1_FreeMaxBSP();
 	} //end if
 	//Half-Life also only uses a version number
 	else if (idheader.ident == HL_BSPVERSION)
 	{
 		ResetMapLoading();
 		HL_AllocMaxBSP();
 		HL_LoadMapFromBSP(qf->filename, qf->offset, qf->length);
 		HL_FreeMaxBSP();
 	} //end if
 	else
 	{
 		Error("unknown BSP format %c%c%c%c, version %d\n",
 										(idheader.ident & 0xFF),
 										((idheader.ident >> 8) & 0xFF),
 										((idheader.ident >> 16) & 0xFF),
 										((idheader.ident >> 24) & 0xFF), idheader.version);
 		return false;
 	} //end if
 	//
 	return true;
 } //end of the function LoadMapFromBSP