Quake-III-Arena

Brush.cpp (107620B)

---

 /*
 ===========================================================================
 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 "stdafx.h"
 #include <assert.h>
 #include "qe3.h"
 #include "winding.h"
 
 
 // globals
 
 int g_nBrushId = 0;
 
 const char* Brush_Name(brush_t *b)
 {
   static char cBuff[1024];
 	b->numberId = g_nBrushId++;
 	if (g_qeglobals.m_bBrushPrimitMode)
   {
     sprintf(cBuff, "Brush %i", b->numberId);
     Brush_SetEpair(b, "Name", cBuff);
   }
   return cBuff;
 }
 
 brush_t *Brush_Alloc()
 {
   brush_t *b = (brush_t*)qmalloc(sizeof(brush_t));
   return b;
 }
 
 
 
 
 void PrintWinding (winding_t *w)
 {
 	int		i;
 	
 	printf ("-------------\n");
 	for (i=0 ; i<w->numpoints ; i++)
 		printf ("(%5.2f, %5.2f, %5.2f)\n", w->points[i][0]
 		, w->points[i][1], w->points[i][2]);
 }
 
 void PrintPlane (plane_t *p)
 {
   printf ("(%5.2f, %5.2f, %5.2f) : %5.2f\n",  p->normal[0],  p->normal[1], 
   p->normal[2],  p->dist);
 }
 
 void PrintVector (vec3_t v)
 {
   printf ("(%5.2f, %5.2f, %5.2f)\n",  v[0],  v[1], v[2]);
 }
 
 
 /*
 =============================================================================
 
 			TEXTURE COORDINATES
 
 =============================================================================
 */
 
 
 /*
 ==================
 textureAxisFromPlane
 ==================
 */
 vec3_t	baseaxis[18] =
 {
 {0,0,1}, {1,0,0}, {0,-1,0},			// floor
 {0,0,-1}, {1,0,0}, {0,-1,0},		// ceiling
 {1,0,0}, {0,1,0}, {0,0,-1},			// west wall
 {-1,0,0}, {0,1,0}, {0,0,-1},		// east wall
 {0,1,0}, {1,0,0}, {0,0,-1},			// south wall
 {0,-1,0}, {1,0,0}, {0,0,-1}			// north wall
 };
 
 void TextureAxisFromPlane(plane_t *pln, vec3_t xv, vec3_t yv)
 {
 	int		bestaxis;
 	float	dot,best;
 	int		i;
 	
 	best = 0;
 	bestaxis = 0;
 	
 	for (i=0 ; i<6 ; i++)
 	{
 		dot = DotProduct (pln->normal, baseaxis[i*3]);
 		if (dot > best)
 		{
 			best = dot;
 			bestaxis = i;
 		}
 	}
 	
 	VectorCopy (baseaxis[bestaxis*3+1], xv);
 	VectorCopy (baseaxis[bestaxis*3+2], yv);
 }
 
 
 
 float	lightaxis[3] = {0.6, 0.8, 1.0};
 /*
 ================
 SetShadeForPlane
 
 Light different planes differently to
 improve recognition
 ================
 */
 float SetShadeForPlane (plane_t *p)
 {
 	int		i;
 	float	f;
 
 	// axial plane
 	for (i=0 ; i<3 ; i++)
 		if (fabs(p->normal[i]) > 0.9)
 		{
 			f = lightaxis[i];
 			return f;
 		}
 
 	// between two axial planes
 	for (i=0 ; i<3 ; i++)
 		if (fabs(p->normal[i]) < 0.1)
 		{
 			f = (lightaxis[(i+1)%3] + lightaxis[(i+2)%3])/2;
 			return f;
 		}
 
 	// other
 	f= (lightaxis[0] + lightaxis[1] + lightaxis[2]) / 3;
 	return f;
 }
 
 vec3_t  vecs[2];
 float	shift[2];
 
 /*
 ================
 Face_Alloc
 ================
 */
 face_t *Face_Alloc( void )
 {
 	face_t *f = (face_t*)qmalloc( sizeof( *f ) );
 	
 	if (g_qeglobals.bSurfacePropertiesPlugin)
 		f->pData = static_cast<void *>( g_SurfaceTable.m_pfnTexdefAlloc( f ) );
 
 	return f;
 }
 
 /*
 ================
 Face_Free
 ================
 */
 void Face_Free( face_t *f )
 {
 	assert( f != 0 );
 
 	if ( f->face_winding )
 	{
 		free( f->face_winding );
 		f->face_winding = 0;
 	}
 
 	if (g_qeglobals.bSurfacePropertiesPlugin)
 	{
 #ifdef _DEBUG
 		if ( !f->pData )
 		{
 			Sys_Printf("WARNING: unexpected IPluginTexdef is NULL in Face_Free\n");
 		}
 		else
 #endif
 		GETPLUGINTEXDEF(f)->DecRef();
 	}
 
 	f->texdef.~texdef_t();;
 
 	free( f );
 }
 
 /*
 ================
 Face_Clone
 ================
 */
 face_t	*Face_Clone (face_t *f)
 {
 	face_t	*n;
 
 	n = Face_Alloc();
 	n->texdef = f->texdef;
 
 	memcpy (n->planepts, f->planepts, sizeof(n->planepts));
 
 	// all other fields are derived, and will be set by Brush_Build
 	return n;
 }
 
 /*
 ================
 Face_FullClone
 
 makes an exact copy of the face
 ================
 */
 face_t	*Face_FullClone (face_t *f)
 {
 	face_t	*n;
 
 	n = Face_Alloc();
 	n->texdef = f->texdef;
 	memcpy(n->planepts, f->planepts, sizeof(n->planepts));
 	memcpy(&n->plane, &f->plane, sizeof(plane_t));
 	if (f->face_winding)
 		n->face_winding = Winding_Clone(f->face_winding);
 	else
 		n->face_winding = NULL;
 	n->d_texture = Texture_ForName( n->texdef.name );
 	return n;
 }
 
 /*
 ================
 Clamp
 ================
 */
 void Clamp(float& f, int nClamp)
 {
   float fFrac = f - static_cast<int>(f);
   f = static_cast<int>(f) % nClamp;
   f += fFrac;
 }
 
 /*
 ================
 Face_MoveTexture
 ================
 */
 void Face_MoveTexture(face_t *f, vec3_t delta)
 {
 	vec3_t vX, vY;
 /*
 #ifdef _DEBUG
 	if (g_PrefsDlg.m_bBrushPrimitMode)
 		Sys_Printf("Warning : Face_MoveTexture not done in brush primitive mode\n");
 #endif
 */
 	if (g_qeglobals.m_bBrushPrimitMode)
 		Face_MoveTexture_BrushPrimit( f, delta );
 	else
 	{
 		TextureAxisFromPlane(&f->plane, vX, vY);
 
 		vec3_t vDP, vShift;
 		vDP[0] = DotProduct(delta, vX);
 		vDP[1] = DotProduct(delta, vY);
 
 		double fAngle = f->texdef.rotate  / 180 * Q_PI;
 		double c = cos(fAngle);
 		double s = sin(fAngle);
 
 		vShift[0] = vDP[0] * c - vDP[1] * s;
 		vShift[1] = vDP[0] * s + vDP[1] * c;
 
 		if (!f->texdef.scale[0])
 			f->texdef.scale[0] = 1;
 		if (!f->texdef.scale[1])
 			f->texdef.scale[1] = 1;
 
 		f->texdef.shift[0] -= vShift[0] / f->texdef.scale[0];
 		f->texdef.shift[1] -= vShift[1] / f->texdef.scale[1];
   
 		// clamp the shifts
 		Clamp(f->texdef.shift[0], f->d_texture->width);
 		Clamp(f->texdef.shift[1], f->d_texture->height);
 	}
 }
 
 /*
 ================
 Face_SetColor
 ================
 */
 void Face_SetColor (brush_t *b, face_t *f, float fCurveColor) 
 {
 	float	shade;
 	qtexture_t *q;
 
 	q = f->d_texture;
 
 	// set shading for face
 	shade = SetShadeForPlane (&f->plane);
 	if (g_pParentWnd->GetCamera()->Camera().draw_mode == cd_texture && !b->owner->eclass->fixedsize)
 	{
 		//if (b->curveBrush)
 		//  shade = fCurveColor;
 		f->d_color[0] = 
 		f->d_color[1] = 
 		f->d_color[2] = shade;
 	}
 	else
 	{
 		f->d_color[0] = shade*q->color[0];
 		f->d_color[1] = shade*q->color[1];
 		f->d_color[2] = shade*q->color[2];
 	}
 }
 
 /*
 ================
 Face_TextureVectors
 TTimo: NOTE: this is never to get called while in brush primitives mode
 ================
 */
 void Face_TextureVectors (face_t *f, float STfromXYZ[2][4])
 {
 	vec3_t		pvecs[2];
 	int			sv, tv;
 	float		ang, sinv, cosv;
 	float		ns, nt;
 	int			i,j;
 	qtexture_t *q;
 	texdef_t	*td;
 
 #ifdef _DEBUG
 	//++timo when playing with patches, this sometimes get called and the Warning is displayed
 	// find some way out ..
 	if (g_qeglobals.m_bBrushPrimitMode && !g_qeglobals.bNeedConvert)
 		Sys_Printf("Warning : illegal call of Face_TextureVectors in brush primitive mode\n");
 #endif
 
 	td = &f->texdef;
 	q = f->d_texture;
 
 	memset (STfromXYZ, 0, 8*sizeof(float));
 
 	if (!td->scale[0])
 		td->scale[0] = (g_PrefsDlg.m_bHiColorTextures) ? 0.5 : 1;
 	if (!td->scale[1])
 		td->scale[1] = (g_PrefsDlg.m_bHiColorTextures) ? 0.5 : 1;
 
 	// get natural texture axis
 	TextureAxisFromPlane(&f->plane, pvecs[0], pvecs[1]);
 
 	// rotate axis
 	if (td->rotate == 0)
 		{ sinv = 0 ; cosv = 1; }
 	else if (td->rotate == 90)
 		{ sinv = 1 ; cosv = 0; }
 	else if (td->rotate == 180)
 		{ sinv = 0 ; cosv = -1; }
 	else if (td->rotate == 270)
 		{ sinv = -1 ; cosv = 0; }
 	else
 	{	
 		ang = td->rotate / 180 * Q_PI;
 		sinv = sin(ang);
 		cosv = cos(ang);
 	}
 
 	if (pvecs[0][0])
 		sv = 0;
 	else if (pvecs[0][1])
 		sv = 1;
 	else
 		sv = 2;
 				
 	if (pvecs[1][0])
 		tv = 0;
 	else if (pvecs[1][1])
 		tv = 1;
 	else
 		tv = 2;
 					
 	for (i=0 ; i<2 ; i++) {
 		ns = cosv * pvecs[i][sv] - sinv * pvecs[i][tv];
 		nt = sinv * pvecs[i][sv] +  cosv * pvecs[i][tv];
 		STfromXYZ[i][sv] = ns;
 		STfromXYZ[i][tv] = nt;
 	}
 
 	// scale
 	for (i=0 ; i<2 ; i++)
 		for (j=0 ; j<3 ; j++)
 			STfromXYZ[i][j] = STfromXYZ[i][j] / td->scale[i];
 
 	// shift
 	STfromXYZ[0][3] = td->shift[0];
 	STfromXYZ[1][3] = td->shift[1];
 
 	for (j=0 ; j<4 ; j++) {
 		STfromXYZ[0][j] /= q->width;
 		STfromXYZ[1][j] /= q->height;
 	}
 }
 
 /*
 ================
 Face_MakePlane
 ================
 */
 void Face_MakePlane (face_t *f)
 {
 	int		j;
 	vec3_t	t1, t2, t3;
 
 	// convert to a vector / dist plane
 	for (j=0 ; j<3 ; j++)
 	{
 		t1[j] = f->planepts[0][j] - f->planepts[1][j];
 		t2[j] = f->planepts[2][j] - f->planepts[1][j];
 		t3[j] = f->planepts[1][j];
 	}
 	
 	CrossProduct(t1,t2, f->plane.normal);
 	if (VectorCompare (f->plane.normal, vec3_origin))
 		printf ("WARNING: brush plane with no normal\n");
 	VectorNormalize (f->plane.normal);
 	f->plane.dist = DotProduct (t3, f->plane.normal);
 }
 
 /*
 ================
 EmitTextureCoordinates
 ================
 */
 void EmitTextureCoordinates ( float *xyzst, qtexture_t *q, face_t *f)
 {
 	float	STfromXYZ[2][4];
 
 	Face_TextureVectors (f,  STfromXYZ);
 	xyzst[3] = DotProduct (xyzst, STfromXYZ[0]) + STfromXYZ[0][3];
 	xyzst[4] = DotProduct (xyzst, STfromXYZ[1]) + STfromXYZ[1][3];
 }
 
 //==========================================================================
 
 /*
 ================
 Brush_MakeFacePlanes
 ================
 */
 void Brush_MakeFacePlanes (brush_t *b)
 {
 	face_t	*f;
 
 	for (f=b->brush_faces ; f ; f=f->next)
 	{
 		Face_MakePlane (f);
 	}
 }
 
 /*
 ================
 DrawBrushEntityName
 ================
 */
 void DrawBrushEntityName (brush_t *b)
 {
 	char	*name;
 	//float	a, s, c;
 	//vec3_t	mid;
 	//int		i;
 
 	if (!b->owner)
 		return;		// during contruction
 
 	if (b->owner == world_entity)
 		return;
 
 	if (b != b->owner->brushes.onext)
 		return;	// not key brush
 
 // MERGEME
 #if 0
 	if (!(g_qeglobals.d_savedinfo.exclude & EXCLUDE_ANGLES))
 	{
 		// draw the angle pointer
 		a = FloatForKey (b->owner, "angle");
 		if (a)
 		{
 			s = sin (a/180*Q_PI);
 			c = cos (a/180*Q_PI);
 			for (i=0 ; i<3 ; i++)
 				mid[i] = (b->mins[i] + b->maxs[i])*0.5; 
 
 			qglBegin (GL_LINE_STRIP);
 			qglVertex3fv (mid);
 			mid[0] += c*8;
 			mid[1] += s*8;
 			mid[2] += s*8;
 			qglVertex3fv (mid);
 			mid[0] -= c*4;
 			mid[1] -= s*4;
 			mid[2] -= s*4;
 			mid[0] -= s*4;
 			mid[1] += c*4;
 			mid[2] += c*4;
 			qglVertex3fv (mid);
 			mid[0] += c*4;
 			mid[1] += s*4;
 			mid[2] += s*4;
 			mid[0] += s*4;
 			mid[1] -= c*4;
 			mid[2] -= c*4;
 			qglVertex3fv (mid);
 			mid[0] -= c*4;
 			mid[1] -= s*4;
 			mid[2] -= s*4;
 			mid[0] += s*4;
 			mid[1] -= c*4;
 			mid[2] -= c*4;
 			qglVertex3fv (mid);
 			qglEnd ();
 		}
 	}
 #endif
 
 	if (g_qeglobals.d_savedinfo.show_names)
 	{
 		name = ValueForKey (b->owner, "classname");
 		qglRasterPos3f (b->mins[0]+4, b->mins[1]+4, b->mins[2]+4);
 		qglCallLists (strlen(name), GL_UNSIGNED_BYTE, name);
 	}
 }
 
 /*
 =================
 Brush_MakeFaceWinding
 
 returns the visible polygon on a face
 =================
 */
 winding_t *Brush_MakeFaceWinding (brush_t *b, face_t *face)
 {
 	winding_t	*w;
 	face_t		*clip;
 	plane_t			plane;
 	qboolean		past;
 
 	// get a poly that covers an effectively infinite area
 	w = Winding_BaseForPlane (&face->plane);
 
 	// chop the poly by all of the other faces
 	past = false;
 	for (clip = b->brush_faces ; clip && w ; clip=clip->next)
 	{
 		if (clip == face)
 		{
 			past = true;
 			continue;
 		}
 		if (DotProduct (face->plane.normal, clip->plane.normal) > 0.999
 			&& fabs(face->plane.dist - clip->plane.dist) < 0.01 )
 		{	// identical plane, use the later one
 			if (past)
 			{
 				free (w);
 				return NULL;
 			}
 			continue;
 		}
 
 		// flip the plane, because we want to keep the back side
 		VectorSubtract (vec3_origin,clip->plane.normal, plane.normal);
 		plane.dist = -clip->plane.dist;
 		
 		w = Winding_Clip (w, &plane, false);
 		if (!w)
 			return w;
 	}
 	
 	if (w->numpoints < 3)
 	{
 		free(w);
 		w = NULL;
 	}
 
 	if (!w)
 		printf ("unused plane\n");
 
 	return w;
 }
 
 /*
 =================
 Brush_SnapPlanepts
 =================
 */
 void Brush_SnapPlanepts (brush_t *b)
 {
 	int		i, j;
 	face_t	*f;
 
   if (g_PrefsDlg.m_bNoClamp)
     return;
 
 	for (f=b->brush_faces ; f; f=f->next)
 		for (i=0 ; i<3 ; i++)
 			for (j=0 ; j<3 ; j++)
 				f->planepts[i][j] = floor (f->planepts[i][j] + 0.5);
 }
 	
 /*
 ** Brush_Build
 **
 ** Builds a brush rendering data and also sets the min/max bounds
 */
 // TTimo
 // added a bConvert flag to convert between old and new brush texture formats
 // TTimo
 // brush grouping: update the group treeview if necessary
 void Brush_Build( brush_t *b, bool bSnap, bool bMarkMap, bool bConvert )
 {
 	bool		bLocalConvert;
 
 #ifdef _DEBUG
 	if (!g_qeglobals.m_bBrushPrimitMode && bConvert)
 		Sys_Printf("Warning : conversion from brush primitive to old brush format not implemented\n");
 #endif
 
 	// if bConvert is set and g_qeglobals.bNeedConvert is not, that just means we need convert for this brush only
 	if (bConvert && !g_qeglobals.bNeedConvert)
 	{
 		bLocalConvert = true;
 		g_qeglobals.bNeedConvert = true;
 	}
 
 	/*
 	** build the windings and generate the bounding box
 	*/
 	Brush_BuildWindings(b, bSnap);
 
 	Patch_BuildPoints (b);
 
 	/*
 	** move the points and edges if in select mode
 	*/
 	if (g_qeglobals.d_select_mode == sel_vertex || g_qeglobals.d_select_mode == sel_edge)
 		SetupVertexSelection ();
 
     if (b->itemOwner == NULL)
       Group_AddToProperGroup(b);
 
 	if (bMarkMap)
 	{
 		Sys_MarkMapModified();
 	}
 
 	if (bLocalConvert)
 		g_qeglobals.bNeedConvert = false;
 }
 
 /*
 ==============
 Brush_SplitBrushByFace
 
 The incoming brush is NOT freed.
 The incoming face is NOT left referenced.
 ==============
 */
 void Brush_SplitBrushByFace (brush_t *in, face_t *f, brush_t **front, brush_t **back)
 {
 	brush_t	*b;
 	face_t	*nf;
 	vec3_t	temp;
 
 	b = Brush_Clone (in);
 	nf = Face_Clone (f);
 
 	nf->texdef = b->brush_faces->texdef;
 	nf->next = b->brush_faces;
 	b->brush_faces = nf;
 
 	Brush_Build( b );
 	Brush_RemoveEmptyFaces ( b );
 	if ( !b->brush_faces )
 	{	// completely clipped away
 		Brush_Free (b);
 		*back = NULL;
 	}
 	else
 	{
 		Entity_LinkBrush (in->owner, b);
 		*back = b;
 	}
 
 	b = Brush_Clone (in);
 	nf = Face_Clone (f);
 	// swap the plane winding
 	VectorCopy (nf->planepts[0], temp);
 	VectorCopy (nf->planepts[1], nf->planepts[0]);
 	VectorCopy (temp, nf->planepts[1]);
 
 	nf->texdef = b->brush_faces->texdef;
 	nf->next = b->brush_faces;
 	b->brush_faces = nf;
 
 	Brush_Build( b );
 	Brush_RemoveEmptyFaces ( b );
 	if ( !b->brush_faces )
 	{	// completely clipped away
 		Brush_Free (b);
 		*front = NULL;
 	}
 	else
 	{
 		Entity_LinkBrush (in->owner, b);
 		*front = b;
 	}
 }
 
 /*
 =================
 Brush_BestSplitFace
 
 returns the best face to split the brush with.
 return NULL if the brush is convex
 =================
 */
 face_t *Brush_BestSplitFace(brush_t *b)
 {
 	face_t *face, *f, *bestface;
 	winding_t *front, *back;
 	int splits, tinywindings, value, bestvalue;
 
 	bestvalue = 999999;
 	bestface = NULL;
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		splits = 0;
 		tinywindings = 0;
 		for (f = b->brush_faces; f; f = f->next)
 		{
 			if (f == face) continue;
 			//
 			Winding_SplitEpsilon(f->face_winding, face->plane.normal, face->plane.dist, 0.1, &front, &back);
 
 			if (!front)
 			{
 				Winding_Free(back);
 			}
 			else if (!back)
 			{
 				Winding_Free(front);
 			}
 			else
 			{
 				splits++;
 				if (Winding_IsTiny(front)) tinywindings++;
 				if (Winding_IsTiny(back)) tinywindings++;
 			}
 		}
 		if (splits)
 		{
 			value = splits + 50 * tinywindings;
 			if (value < bestvalue)
 			{
 				bestvalue = value;
 				bestface = face;
 			}
 		}
 	}
 	return bestface;
 }
 
 /*
 =================
 Brush_MakeConvexBrushes
 
 MrE FIXME: this doesn't work because the old
 		   Brush_SplitBrushByFace is used
 Turns the brush into a minimal number of convex brushes.
 If the input brush is convex then it will be returned.
 Otherwise the input brush will be freed.
 NOTE: the input brush should have windings for the faces.
 =================
 */
 brush_t *Brush_MakeConvexBrushes(brush_t *b)
 {
 	brush_t *front, *back, *end;
 	face_t *face;
 
 	b->next = NULL;
 	face = Brush_BestSplitFace(b);
 	if (!face) return b;
 	Brush_SplitBrushByFace(b, face, &front, &back);
 	//this should never happen
 	if (!front && !back) return b;
 	Brush_Free(b);
 	if (!front)
 		return Brush_MakeConvexBrushes(back);
 	b = Brush_MakeConvexBrushes(front);
 	if (back)
 	{
 		for (end = b; end->next; end = end->next);
 		end->next = Brush_MakeConvexBrushes(back);
 	}
 	return b;
 }
 
 /*
 =================
 Brush_Convex
 =================
 */
 int Brush_Convex(brush_t *b)
 {
 	face_t *face1, *face2;
 
 	for (face1 = b->brush_faces; face1; face1 = face1->next)
 	{
 		if (!face1->face_winding) continue;
 		for (face2 = b->brush_faces; face2; face2 = face2->next)
 		{
 			if (face1 == face2) continue;
 			if (!face2->face_winding) continue;
 			if (Winding_PlanesConcave(face1->face_winding, face2->face_winding,
 										face1->plane.normal, face2->plane.normal,
 										face1->plane.dist, face2->plane.dist))
 			{
 				return false;
 			}
 		}
 	}
 	return true;
 }
 
 /*
 =================
 Brush_MoveVertexes_old1
 
 - The input brush must have face windings.
 - The input brush must be a brush with faces that do not intersect.
 - The input brush does not have to be convex.
 - The vertex will not be moved if the movement either causes the
   brush to have faces that intersect or causes the brush to be
   flipped inside out.
   (For instance a tetrahedron can easily be flipped inside out
   without having faces that intersect.)
 - The created brush does not have to be convex.
 - Returns true if the vertex movement is performed.
 =================
 */
 
 #define MAX_MOVE_FACES		64
 #define INTERSECT_EPSILON	0.1
 #define POINT_EPSILON		0.3
 
 int Brush_MoveVertex_old1(brush_t *b, vec3_t vertex, vec3_t delta, vec3_t end, bool bSnap)
 {
 	face_t *f, *face, *newface, *lastface, *nextface;
 	face_t *movefaces[MAX_MOVE_FACES];
 	int movefacepoints[MAX_MOVE_FACES];
 	winding_t *w, tmpw;
 	int i, j, k, nummovefaces, result;
 	float dot;
 
 	result = false;
 	//
 	tmpw.numpoints = 3;
 	tmpw.maxpoints = 3;
 	VectorAdd(vertex, delta, end);
 	//snap or not?
 	if (bSnap)
 		for (i = 0; i < 3; i++)
 			end[i] = floor(end[i] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	//chop off triangles from all brush faces that use the to be moved vertex
 	//store pointers to these chopped off triangles in movefaces[]
 	nummovefaces = 0;
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		w = face->face_winding;
 		if (!w) continue;
 		for (i = 0; i < w->numpoints; i++)
 		{
 			if (Point_Equal(w->points[i], vertex, POINT_EPSILON))
 			{
 				if (face->face_winding->numpoints <= 3)
 				{
 					movefacepoints[nummovefaces] = i;
 					movefaces[nummovefaces++] = face;
 					break;
 				}
 				dot = DotProduct(end, face->plane.normal) - face->plane.dist;
 				//if the end point is in front of the face plane
 				if (dot > 0.1)
 				{
 					//fanout triangle subdivision
 					for (k = i; k < i + w->numpoints-3; k++)
 					{
 						VectorCopy(w->points[i], tmpw.points[0]);
 						VectorCopy(w->points[(k+1) % w->numpoints], tmpw.points[1]);
 						VectorCopy(w->points[(k+2) % w->numpoints], tmpw.points[2]);
 						//
 						newface = Face_Clone(face);
 						//get the original
 						for (f = face; f->original; f = f->original) ;
 						newface->original = f;
 						//store the new winding
 						if (newface->face_winding) Winding_Free(newface->face_winding);
 						newface->face_winding = Winding_Clone(&tmpw);
 						//get the texture
 						newface->d_texture = Texture_ForName( newface->texdef.name );
 						//add the face to the brush
 						newface->next = b->brush_faces;
 						b->brush_faces = newface;
 						//add this new triangle to the move faces
 						movefacepoints[nummovefaces] = 0;
 						movefaces[nummovefaces++] = newface;
 					}
 					//give the original face a new winding
 					VectorCopy(w->points[(i-2+w->numpoints) % w->numpoints], tmpw.points[0]);
 					VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[1]);
 					VectorCopy(w->points[i], tmpw.points[2]);
 					Winding_Free(face->face_winding);
 					face->face_winding = Winding_Clone(&tmpw);
 					//add the original face to the move faces
 					movefacepoints[nummovefaces] = 2;
 					movefaces[nummovefaces++] = face;
 				}
 				else
 				{
 					//chop a triangle off the face
 					VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[0]);
 					VectorCopy(w->points[i], tmpw.points[1]);
 					VectorCopy(w->points[(i+1) % w->numpoints], tmpw.points[2]);
 					//remove the point from the face winding
 					Winding_RemovePoint(w, i);
 					//get texture crap right
 					Face_SetColor(b, face, 1.0);
 					for (j = 0; j < w->numpoints; j++)
 						EmitTextureCoordinates(w->points[j], face->d_texture, face);
 					//make a triangle face
 					newface = Face_Clone(face);
 					//get the original
 					for (f = face; f->original; f = f->original) ;
 					newface->original = f;
 					//store the new winding
 					if (newface->face_winding) Winding_Free(newface->face_winding);
 					newface->face_winding = Winding_Clone(&tmpw);
 					//get the texture
 					newface->d_texture = Texture_ForName( newface->texdef.name );
 					//add the face to the brush
 					newface->next = b->brush_faces;
 					b->brush_faces = newface;
 					//
 					movefacepoints[nummovefaces] = 1;
 					movefaces[nummovefaces++] = newface;
 				}
 				break;
 			}
 		}
 	}
 	//now movefaces contains pointers to triangle faces that
 	//contain the to be moved vertex
 
 	//check if the move is valid
 	int l;
 	vec3_t p1, p2;
 	winding_t *w2;
 	plane_t plane;
 
 	face = NULL;
 	VectorCopy(vertex, tmpw.points[1]);
 	VectorCopy(end, tmpw.points[2]);
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		for (i = 0; i < nummovefaces; i++)
 		{
 			if (face == movefaces[i])
 				break;
 		}
 		if (i < nummovefaces)
 			continue;
 		//the delta vector may not intersect with any of the not move faces
 		if (Winding_VectorIntersect(face->face_winding, &face->plane, vertex, end, INTERSECT_EPSILON))
 			break;
 		//if the end point of the to be moved vertex is near this not move face
 		if (abs(DotProduct(face->plane.normal, end) - face->plane.dist) < 0.5)
 		{
 			//the end point may not be inside or very close to the not move face winding
 			if (Winding_PointInside(face->face_winding, &face->plane, end, 0.5))
 				break;
 		}
 		for (i = 0; i < nummovefaces; i++)
 		{
 			w = movefaces[i]->face_winding;
 			j = movefacepoints[i];
 			for (k = -1; k <= 1; k += 2)
 			{
 				//check if the new edge will not intersect with the not move face
 				VectorCopy(w->points[(j + k + w->numpoints) % w->numpoints], tmpw.points[0]);
 				if (Winding_VectorIntersect(face->face_winding, &face->plane, tmpw.points[0], end, INTERSECT_EPSILON))
 				{
 					//ok the new edge instersects with the not move face
 					//we can't perform the vertex movement
 					//break;
 				}
 				//check if the not move face intersects the "movement winding"
 				Winding_Plane(&tmpw, plane.normal, &plane.dist);
 				w2 = face->face_winding;
 				for (l = 0; l < w2->numpoints; l++)
 				{
 					VectorCopy(w2->points[l], p1);
 					if (Point_Equal(p1, tmpw.points[0], POINT_EPSILON)) continue;
 					VectorCopy(w2->points[(l+1) % w2->numpoints], p2);
 					if (Point_Equal(p2, tmpw.points[0], POINT_EPSILON)) continue;
 					if (Winding_VectorIntersect(&tmpw, &plane, p1, p2, INTERSECT_EPSILON))
 						break;
 				}
 				if (l < w2->numpoints)
 				{
 					//ok this not move face intersects the "movement winding"
 					//we can't perform the vertex movement
 					break;
 				}
 			}
 			if (k <= 1) break;
 		}
 		if (i < nummovefaces)
 			break;
 	}
 	if (!face)
 	{
 		//ok the move was valid
 		//now move all the vertexes of the movefaces
 		for (i = 0; i < nummovefaces; i++)
 		{
 			VectorCopy(end, movefaces[i]->face_winding->points[movefacepoints[i]]);
 			//create new face plane
 			for (j = 0; j < 3; j++)
 			{
 				VectorCopy(movefaces[i]->face_winding->points[j], movefaces[i]->planepts[j]);
 			}
 			Face_MakePlane(movefaces[i]);
 		}
 		result = true;
 	}
 	//get texture crap right
 	for (i = 0; i < nummovefaces; i++)
 	{
 		Face_SetColor(b, movefaces[i], 1.0);
 		for (j = 0; j < movefaces[i]->face_winding->numpoints; j++)
 			EmitTextureCoordinates(movefaces[i]->face_winding->points[j], movefaces[i]->d_texture, movefaces[i]);
 	}
 
 	//now try to merge faces with their original faces
 	lastface = NULL;
 	for (face = b->brush_faces; face; face = nextface)
 	{
 		nextface = face->next;
 		if (!face->original)
 		{
 			lastface = face;
 			continue;
 		}
 		if (!Plane_Equal(&face->plane, &face->original->plane, false))
 		{
 			lastface = face;
 			continue;
 		}
 		w = Winding_TryMerge(face->face_winding, face->original->face_winding, face->plane.normal, true);
 		if (!w)
 		{
 			lastface = face;
 			continue;
 		}
 		Winding_Free(face->original->face_winding);
 		face->original->face_winding = w;
 		//get texture crap right
 		Face_SetColor(b, face->original, 1.0);
 		for (j = 0; j < face->original->face_winding->numpoints; j++)
 			EmitTextureCoordinates(face->original->face_winding->points[j], face->original->d_texture, face->original);
 		//remove the face that was merged with the original
 		if (lastface) lastface->next = face->next;
 		else b->brush_faces = face->next;
 		Face_Free(face);
 	}
 	return result;
 }
 
 /*
 =================
 Brush_MoveVertexes_old2
 
 - The input brush must be convex
 - The input brush must have face windings.
 - The output brush will be convex.
 - Returns true if the vertex movement is performed.
 =================
 */
 
 #define MAX_MOVE_FACES		64
 #define INTERSECT_EPSILON	0.1
 #define POINT_EPSILON		0.3
 
 int Brush_MoveVertex_old2(brush_t *b, vec3_t vertex, vec3_t delta, vec3_t end, bool bSnap)
 {
 	face_t *f, *face, *newface, *lastface, *nextface;
 	face_t *movefaces[MAX_MOVE_FACES];
 	int movefacepoints[MAX_MOVE_FACES];
 	winding_t *w, tmpw;
 	int i, j, k, nummovefaces, result;
 	float dot;
 
 	result = true;
 	//
 	tmpw.numpoints = 3;
 	tmpw.maxpoints = 3;
 	VectorAdd(vertex, delta, end);
 	//snap or not?
 	if (bSnap)
 		for (i = 0; i < 3; i++)
 			end[i] = floor(end[i] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	//chop off triangles from all brush faces that use the to be moved vertex
 	//store pointers to these chopped off triangles in movefaces[]
 	nummovefaces = 0;
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		w = face->face_winding;
 		if (!w) continue;
 		for (i = 0; i < w->numpoints; i++)
 		{
 			if (Point_Equal(w->points[i], vertex, POINT_EPSILON))
 			{
 				if (face->face_winding->numpoints <= 3)
 				{
 					movefacepoints[nummovefaces] = i;
 					movefaces[nummovefaces++] = face;
 					break;
 				}
 				dot = DotProduct(end, face->plane.normal) - face->plane.dist;
 				//if the end point is in front of the face plane
 				if (dot > 0.1)
 				{
 					//fanout triangle subdivision
 					for (k = i; k < i + w->numpoints-3; k++)
 					{
 						VectorCopy(w->points[i], tmpw.points[0]);
 						VectorCopy(w->points[(k+1) % w->numpoints], tmpw.points[1]);
 						VectorCopy(w->points[(k+2) % w->numpoints], tmpw.points[2]);
 						//
 						newface = Face_Clone(face);
 						//get the original
 						for (f = face; f->original; f = f->original) ;
 						newface->original = f;
 						//store the new winding
 						if (newface->face_winding) Winding_Free(newface->face_winding);
 						newface->face_winding = Winding_Clone(&tmpw);
 						//get the texture
 						newface->d_texture = Texture_ForName( newface->texdef.name );
 						//add the face to the brush
 						newface->next = b->brush_faces;
 						b->brush_faces = newface;
 						//add this new triangle to the move faces
 						movefacepoints[nummovefaces] = 0;
 						movefaces[nummovefaces++] = newface;
 					}
 					//give the original face a new winding
 					VectorCopy(w->points[(i-2+w->numpoints) % w->numpoints], tmpw.points[0]);
 					VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[1]);
 					VectorCopy(w->points[i], tmpw.points[2]);
 					Winding_Free(face->face_winding);
 					face->face_winding = Winding_Clone(&tmpw);
 					//add the original face to the move faces
 					movefacepoints[nummovefaces] = 2;
 					movefaces[nummovefaces++] = face;
 				}
 				else
 				{
 					//chop a triangle off the face
 					VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[0]);
 					VectorCopy(w->points[i], tmpw.points[1]);
 					VectorCopy(w->points[(i+1) % w->numpoints], tmpw.points[2]);
 					//remove the point from the face winding
 					Winding_RemovePoint(w, i);
 					//get texture crap right
 					Face_SetColor(b, face, 1.0);
 					for (j = 0; j < w->numpoints; j++)
 						EmitTextureCoordinates(w->points[j], face->d_texture, face);
 					//make a triangle face
 					newface = Face_Clone(face);
 					//get the original
 					for (f = face; f->original; f = f->original) ;
 					newface->original = f;
 					//store the new winding
 					if (newface->face_winding) Winding_Free(newface->face_winding);
 					newface->face_winding = Winding_Clone(&tmpw);
 					//get the texture
 					newface->d_texture = Texture_ForName( newface->texdef.name );
 					//add the face to the brush
 					newface->next = b->brush_faces;
 					b->brush_faces = newface;
 					//
 					movefacepoints[nummovefaces] = 1;
 					movefaces[nummovefaces++] = newface;
 				}
 				break;
 			}
 		}
 	}
 	//now movefaces contains pointers to triangle faces that
 	//contain the to be moved vertex
 
 	//move the vertex
 	for (i = 0; i < nummovefaces; i++)
 	{
 		//move vertex to end position
 		VectorCopy(end, movefaces[i]->face_winding->points[movefacepoints[i]]);
 		//create new face plane
 		for (j = 0; j < 3; j++)
 		{
 			VectorCopy(movefaces[i]->face_winding->points[j], movefaces[i]->planepts[j]);
 		}
 		Face_MakePlane(movefaces[i]);
 	}
 	//if the brush is no longer convex
 	if (!Brush_Convex(b))
 	{
 		for (i = 0; i < nummovefaces; i++)
 		{
 			//move the vertex back to the initial position
 			VectorCopy(vertex, movefaces[i]->face_winding->points[movefacepoints[i]]);
 			//create new face plane
 			for (j = 0; j < 3; j++)
 			{
 				VectorCopy(movefaces[i]->face_winding->points[j], movefaces[i]->planepts[j]);
 			}
 			Face_MakePlane(movefaces[i]);
 		}
 		result = false;
 	}
 	//get texture crap right
 	for (i = 0; i < nummovefaces; i++)
 	{
 		Face_SetColor(b, movefaces[i], 1.0);
 		for (j = 0; j < movefaces[i]->face_winding->numpoints; j++)
 			EmitTextureCoordinates(movefaces[i]->face_winding->points[j], movefaces[i]->d_texture, movefaces[i]);
 	}
 
 	//now try to merge faces with their original faces
 	lastface = NULL;
 	for (face = b->brush_faces; face; face = nextface)
 	{
 		nextface = face->next;
 		if (!face->original)
 		{
 			lastface = face;
 			continue;
 		}
 		if (!Plane_Equal(&face->plane, &face->original->plane, false))
 		{
 			lastface = face;
 			continue;
 		}
 		w = Winding_TryMerge(face->face_winding, face->original->face_winding, face->plane.normal, true);
 		if (!w)
 		{
 			lastface = face;
 			continue;
 		}
 		Winding_Free(face->original->face_winding);
 		face->original->face_winding = w;
 		//get texture crap right
 		Face_SetColor(b, face->original, 1.0);
 		for (j = 0; j < face->original->face_winding->numpoints; j++)
 			EmitTextureCoordinates(face->original->face_winding->points[j], face->original->d_texture, face->original);
 		//remove the face that was merged with the original
 		if (lastface) lastface->next = face->next;
 		else b->brush_faces = face->next;
 		Face_Free(face);
 	}
 	return result;
 }
 
 /*
 =================
 Brush_MoveVertexes
 
 - The input brush must be convex
 - The input brush must have face windings.
 - The output brush will be convex.
 - Returns true if the WHOLE vertex movement is performed.
 =================
 */
 
 #define MAX_MOVE_FACES		64
 
 int Brush_MoveVertex(brush_t *b, vec3_t vertex, vec3_t delta, vec3_t end, bool bSnap)
 {
 	face_t *f, *face, *newface, *lastface, *nextface;
 	face_t *movefaces[MAX_MOVE_FACES];
 	int movefacepoints[MAX_MOVE_FACES];
 	winding_t *w, tmpw;
 	vec3_t start, mid;
 	plane_t plane;
 	int i, j, k, nummovefaces, result, done;
 	float dot, front, back, frac, smallestfrac;
 
 	result = true;
 	//
 	tmpw.numpoints = 3;
 	tmpw.maxpoints = 3;
 	VectorCopy(vertex, start);
 	VectorAdd(vertex, delta, end);
 	//snap or not?
 	if (bSnap)
 		for (i = 0; i < 3; i++)
 			end[i] = floor(end[i] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 	//
 	VectorCopy(end, mid);
 	//if the start and end are the same
 	if (Point_Equal(start, end, 0.3)) return false;
 	//the end point may not be the same as another vertex
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		w = face->face_winding;
 		if (!w) continue;
 		for (i = 0; i < w->numpoints; i++)
 		{
 			if (Point_Equal(w->points[i], end, 0.3))
 			{
 				VectorCopy(vertex, end);
 				return false;
 			}
 		}
 	}
 	//
 	done = false;
 	while(!done)
 	{
 		//chop off triangles from all brush faces that use the to be moved vertex
 		//store pointers to these chopped off triangles in movefaces[]
 		nummovefaces = 0;
 		for (face = b->brush_faces; face; face = face->next)
 		{
 			w = face->face_winding;
 			if (!w) continue;
 			for (i = 0; i < w->numpoints; i++)
 			{
 				if (Point_Equal(w->points[i], start, 0.2))
 				{
 					if (face->face_winding->numpoints <= 3)
 					{
 						movefacepoints[nummovefaces] = i;
 						movefaces[nummovefaces++] = face;
 						break;
 					}
 					dot = DotProduct(end, face->plane.normal) - face->plane.dist;
 					//if the end point is in front of the face plane
 					if (dot > 0.1)
 					{
 						//fanout triangle subdivision
 						for (k = i; k < i + w->numpoints-3; k++)
 						{
 							VectorCopy(w->points[i], tmpw.points[0]);
 							VectorCopy(w->points[(k+1) % w->numpoints], tmpw.points[1]);
 							VectorCopy(w->points[(k+2) % w->numpoints], tmpw.points[2]);
 							//
 							newface = Face_Clone(face);
 							//get the original
 							for (f = face; f->original; f = f->original) ;
 							newface->original = f;
 							//store the new winding
 							if (newface->face_winding) Winding_Free(newface->face_winding);
 							newface->face_winding = Winding_Clone(&tmpw);
 							//get the texture
 							newface->d_texture = Texture_ForName( newface->texdef.name );
 							//add the face to the brush
 							newface->next = b->brush_faces;
 							b->brush_faces = newface;
 							//add this new triangle to the move faces
 							movefacepoints[nummovefaces] = 0;
 							movefaces[nummovefaces++] = newface;
 						}
 						//give the original face a new winding
 						VectorCopy(w->points[(i-2+w->numpoints) % w->numpoints], tmpw.points[0]);
 						VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[1]);
 						VectorCopy(w->points[i], tmpw.points[2]);
 						Winding_Free(face->face_winding);
 						face->face_winding = Winding_Clone(&tmpw);
 						//add the original face to the move faces
 						movefacepoints[nummovefaces] = 2;
 						movefaces[nummovefaces++] = face;
 					}
 					else
 					{
 						//chop a triangle off the face
 						VectorCopy(w->points[(i-1+w->numpoints) % w->numpoints], tmpw.points[0]);
 						VectorCopy(w->points[i], tmpw.points[1]);
 						VectorCopy(w->points[(i+1) % w->numpoints], tmpw.points[2]);
 						//remove the point from the face winding
 						Winding_RemovePoint(w, i);
 						//get texture crap right
 						Face_SetColor(b, face, 1.0);
 						for (j = 0; j < w->numpoints; j++)
 							EmitTextureCoordinates(w->points[j], face->d_texture, face);
 						//make a triangle face
 						newface = Face_Clone(face);
 						//get the original
 						for (f = face; f->original; f = f->original) ;
 						newface->original = f;
 						//store the new winding
 						if (newface->face_winding) Winding_Free(newface->face_winding);
 						newface->face_winding = Winding_Clone(&tmpw);
 						//get the texture
 						newface->d_texture = Texture_ForName( newface->texdef.name );
 						//add the face to the brush
 						newface->next = b->brush_faces;
 						b->brush_faces = newface;
 						//
 						movefacepoints[nummovefaces] = 1;
 						movefaces[nummovefaces++] = newface;
 					}
 					break;
 				}
 			}
 		}
 		//now movefaces contains pointers to triangle faces that
 		//contain the to be moved vertex
 		//
 		done = true;
 		VectorCopy(end, mid);
 		smallestfrac = 1;
 		for (face = b->brush_faces; face; face = face->next)
 		{
 			//check if there is a move face that has this face as the original
 			for (i = 0; i < nummovefaces; i++)
 			{
 				if (movefaces[i]->original == face) break;
 			}
 			if (i >= nummovefaces) continue;
 			//check if the original is not a move face itself
 			for (j = 0; j < nummovefaces; j++)
 			{
 				if (face == movefaces[j]) break;
 			}
 			//if the original is not a move face itself
 			if (j >= nummovefaces)
 			{
 				memcpy(&plane, &movefaces[i]->original->plane, sizeof(plane_t));
 			}
 			else
 			{
 				k = movefacepoints[j];
 				w = movefaces[j]->face_winding;
 				VectorCopy(w->points[(k+1)%w->numpoints], tmpw.points[0]);
 				VectorCopy(w->points[(k+2)%w->numpoints], tmpw.points[1]);
 				//
 				k = movefacepoints[i];
 				w = movefaces[i]->face_winding;
 				VectorCopy(w->points[(k+1)%w->numpoints], tmpw.points[2]);
 				if (!Plane_FromPoints(tmpw.points[0], tmpw.points[1], tmpw.points[2], &plane))
 				{
 					VectorCopy(w->points[(k+2)%w->numpoints], tmpw.points[2]);
 					if (!Plane_FromPoints(tmpw.points[0], tmpw.points[1], tmpw.points[2], &plane))
 						//this should never happen otherwise the face merge did a crappy job a previous pass
 						continue;
 				}
 			}
 			//now we've got the plane to check agains
 			front = DotProduct(start, plane.normal) - plane.dist;
 			back = DotProduct(end, plane.normal) - plane.dist;
 			//if the whole move is at one side of the plane
 			if (front < 0.01 && back < 0.01) continue;
 			if (front > -0.01 && back > -0.01) continue;
 			//if there's no movement orthogonal to this plane at all
 			if (fabs(front-back) < 0.001) continue;
 			//ok first only move till the plane is hit
 			frac = front/(front-back);
 			if (frac < smallestfrac)
 			{
 				mid[0] = start[0] + (end[0] - start[0]) * frac;
 				mid[1] = start[1] + (end[1] - start[1]) * frac;
 				mid[2] = start[2] + (end[2] - start[2]) * frac;
 				smallestfrac = frac;
 			}
 			//
 			done = false;
 		}
 
 		//move the vertex
 		for (i = 0; i < nummovefaces; i++)
 		{
 			//move vertex to end position
 			VectorCopy(mid, movefaces[i]->face_winding->points[movefacepoints[i]]);
 			//create new face plane
 			for (j = 0; j < 3; j++)
 			{
 				VectorCopy(movefaces[i]->face_winding->points[j], movefaces[i]->planepts[j]);
 			}
 			Face_MakePlane(movefaces[i]);
 			if (VectorLength(movefaces[i]->plane.normal) < 0.1)
 				result = false;
 		}
 		//if the brush is no longer convex
 		if (!result || !Brush_Convex(b))
 		{
 			for (i = 0; i < nummovefaces; i++)
 			{
 				//move the vertex back to the initial position
 				VectorCopy(start, movefaces[i]->face_winding->points[movefacepoints[i]]);
 				//create new face plane
 				for (j = 0; j < 3; j++)
 				{
 					VectorCopy(movefaces[i]->face_winding->points[j], movefaces[i]->planepts[j]);
 				}
 				Face_MakePlane(movefaces[i]);
 			}
 			result = false;
 			VectorCopy(start, end);
 			done = true;
 		}
 		else
 		{
 			VectorCopy(mid, start);
 		}
 		//get texture crap right
 		for (i = 0; i < nummovefaces; i++)
 		{
 			Face_SetColor(b, movefaces[i], 1.0);
 			for (j = 0; j < movefaces[i]->face_winding->numpoints; j++)
 				EmitTextureCoordinates(movefaces[i]->face_winding->points[j], movefaces[i]->d_texture, movefaces[i]);
 		}
 
 		//now try to merge faces with their original faces
 		lastface = NULL;
 		for (face = b->brush_faces; face; face = nextface)
 		{
 			nextface = face->next;
 			if (!face->original)
 			{
 				lastface = face;
 				continue;
 			}
 			if (!Plane_Equal(&face->plane, &face->original->plane, false))
 			{
 				lastface = face;
 				continue;
 			}
 			w = Winding_TryMerge(face->face_winding, face->original->face_winding, face->plane.normal, true);
 			if (!w)
 			{
 				lastface = face;
 				continue;
 			}
 			Winding_Free(face->original->face_winding);
 			face->original->face_winding = w;
 			//get texture crap right
 			Face_SetColor(b, face->original, 1.0);
 			for (j = 0; j < face->original->face_winding->numpoints; j++)
 				EmitTextureCoordinates(face->original->face_winding->points[j], face->original->d_texture, face->original);
 			//remove the face that was merged with the original
 			if (lastface) lastface->next = face->next;
 			else b->brush_faces = face->next;
 			Face_Free(face);
 		}
 	}
 	return result;
 }
 
 /*
 =================
 Brush_InsertVertexBetween
 =================
 */
 int Brush_InsertVertexBetween(brush_t *b, vec3_t p1, vec3_t p2)
 {
 	face_t *face;
 	winding_t *w, *neww;
 	vec3_t point;
 	int i, insert;
 
 	if (Point_Equal(p1, p2, 0.4))
 		return false;
 	VectorAdd(p1, p2, point);
 	VectorScale(point, 0.5, point);
 	insert = false;
 	//the end point may not be the same as another vertex
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		w = face->face_winding;
 		if (!w) continue;
 		neww = NULL;
 		for (i = 0; i < w->numpoints; i++)
 		{
 			if (!Point_Equal(w->points[i], p1, 0.1))
 				continue;
 			if (Point_Equal(w->points[(i+1) % w->numpoints], p2, 0.1))
 			{
 				neww = Winding_InsertPoint(w, point, (i+1) % w->numpoints);
 				break;
 			}
 			else if (Point_Equal(w->points[(i-1+w->numpoints) % w->numpoints], p2, 0.3))
 			{
 				neww = Winding_InsertPoint(w, point, i);
 				break;
 			}
 		}
 		if (neww)
 		{
 			Winding_Free(face->face_winding);
 			face->face_winding = neww;
 			insert = true;
 		}
 	}
 	return insert;
 }
 
 
 /*
 =================
 Brush_ResetFaceOriginals
 =================
 */
 void Brush_ResetFaceOriginals(brush_t *b)
 {
 	face_t *face;
 
 	for (face = b->brush_faces; face; face = face->next)
 	{
 		face->original = NULL;
 	}
 }
 
 /*
 =================
 Brush_Parse
 
 The brush is NOT linked to any list
 =================
 */
 //++timo FIXME: when using old brush primitives, the test loop for "Brush" and "patchDef2" "patchDef3" is ran
 // before each face parsing. It works, but it's a performance hit
 brush_t *Brush_Parse (void)
 {
 	brush_t		*b;
 	face_t		*f;
 	int			i,j;
 	
 	g_qeglobals.d_parsed_brushes++;
 	b = Brush_Alloc();
 
 	do
 	{
 		if (!GetToken (true))
 			break;
 		if (!strcmp (token, "}") )
 			break;
 		
 		// handle "Brush" primitive
 		if (strcmpi(token, "brushDef") == 0)
 		{
 			// Timo parsing new brush format
 			g_qeglobals.bPrimitBrushes=true;
 			// check the map is not mixing the two kinds of brushes
 			if (g_qeglobals.m_bBrushPrimitMode)
 			{
 				if (g_qeglobals.bOldBrushes)
 					Sys_Printf("Warning : old brushes and brush primitive in the same file are not allowed ( Brush_Parse )\n");
 			}
 			//++Timo write new brush primitive -> old conversion code for Q3->Q2 conversions ?
 			else
 				Sys_Printf("Warning : conversion code from brush primitive not done ( Brush_Parse )\n");
 			
 			BrushPrimit_Parse(b);
 			if (b == NULL)
 			{
 				Warning ("parsing brush primitive");
 				return NULL;
 			}
 			else
 			{
         		continue;
 			}
 		}
 		if ( strcmpi( token, "terrainDef" ) == 0 )
 		{
 			free (b);
 
 			b = Terrain_Parse();
 			if (b == NULL)
 			{
 				Warning ("parsing terrain/brush");
 				return NULL;
 			}
 			else
 			{
 				continue;
 			}
 		}
 		if (strcmpi(token, "patchDef2") == 0 || strcmpi(token, "patchDef3") == 0)
 		{
 			free (b);
 			
 			// double string compare but will go away soon
 			b = Patch_Parse(strcmpi(token, "patchDef2") == 0);
 			if (b == NULL)
 			{
 				Warning ("parsing patch/brush");
 				return NULL;
 			}
 			else
 			{
 				continue;
 			}
 			// handle inline patch
 		}
 		else
 		{
 			// Timo parsing old brush format
 			g_qeglobals.bOldBrushes=true;
 			if (g_qeglobals.m_bBrushPrimitMode)
 			{
 				// check the map is not mixing the two kinds of brushes
 				if (g_qeglobals.bPrimitBrushes)
 					Sys_Printf("Warning : old brushes and brush primitive in the same file are not allowed ( Brush_Parse )\n");
 				// set the "need" conversion flag
 				g_qeglobals.bNeedConvert=true;
 			}
 			
 			f = Face_Alloc();
 			
 			// add the brush to the end of the chain, so
 			// loading and saving a map doesn't reverse the order
 			
 			f->next = NULL;
 			if (!b->brush_faces)
 			{
 				b->brush_faces = f;
 			}
 			else
 			{
 				face_t *scan;
 				for (scan=b->brush_faces ; scan->next ; scan=scan->next)
 					;
 				scan->next = f;
 			}
 			
 			// read the three point plane definition
 			for (i=0 ; i<3 ; i++)
 			{
 				if (i != 0)
 					GetToken (true);
 				if (strcmp (token, "(") )
 				{
 					Warning ("parsing brush");
 					return NULL;
 				}
 				
 				for (j=0 ; j<3 ; j++)
 				{
 					GetToken (false);
 					f->planepts[i][j] = atof(token);
 				}
 				
 				GetToken (false);
 				if (strcmp (token, ")") )
 				{
 					Warning ("parsing brush");
 					return NULL;
 				}
 			}
 		}
 
 		// Timo
 		// if we have a surface plugin, we'll call the plugin parsing
 		if (g_qeglobals.bSurfacePropertiesPlugin)
 		{
 			GETPLUGINTEXDEF(f)->ParseTexdef();
 		}
 		else
 		{
 			
 			// read the texturedef
 			GetToken (false);
 			f->texdef.SetName(token);
 			if (token[0] == '(')
 			{
 				int i = 32;
 			}
 			GetToken (false);
 			f->texdef.shift[0] = atoi(token);
 			GetToken (false);
 			f->texdef.shift[1] = atoi(token);
 			GetToken (false);
 			f->texdef.rotate = atoi(token);	
 			GetToken (false);
 			f->texdef.scale[0] = atof(token);
 			GetToken (false);
 			f->texdef.scale[1] = atof(token);
 						
 			// the flags and value field aren't necessarily present
 			f->d_texture = Texture_ForName( f->texdef.name );
 			f->texdef.flags = f->d_texture->flags;
 			f->texdef.value = f->d_texture->value;
 			f->texdef.contents = f->d_texture->contents;
 			
 			if (TokenAvailable ())
 			{
 				GetToken (false);
 				f->texdef.contents = atoi(token);
 				GetToken (false);
 				f->texdef.flags = atoi(token);
 				GetToken (false);
 				f->texdef.value = atoi(token);
 			}
 			
 		}
 	} while (1);
 	
 	return b;
 }
 
 /*
 =================
 QERApp_MapPrintf_FILE
 callback for surface properties plugin
 must fit a PFN_QERAPP_MAPPRINTF ( see isurfaceplugin.h )
 =================
 */
 // carefully initialize !
 FILE * g_File;
 void WINAPI QERApp_MapPrintf_FILE( char *text, ... )
 {
 	va_list argptr;
 	char	buf[32768];
 
 	va_start (argptr,text);
 	vsprintf (buf, text,argptr);
 	va_end (argptr);
 
 	fprintf( g_File, buf );
 }
 
 
 /*
 ==============
 Brush_SetEpair
 sets an epair for the given brush
 ==============
 */
 void Brush_SetEpair(brush_t *b, const char *pKey, const char *pValue)
 {
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
     if (b->patchBrush)
     {
       Patch_SetEpair(b->pPatch, pKey, pValue);
     }
     else if (b->terrainBrush)
     {
       Terrain_SetEpair(b->pTerrain, pKey, pValue);
     }
     else
     {
 		  SetKeyValue(b->epairs, pKey, pValue);
     }
 	}
 	else
 	{
 		Sys_Printf("Can only set key/values in Brush primitive mode\n");
 	}
 }
 
 /* 
 =================
 Brush_GetKeyValue
 =================
 */
 const char* Brush_GetKeyValue(brush_t *b, const char *pKey)
 {
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
     if (b->patchBrush)
     {
       return Patch_GetKeyValue(b->pPatch, pKey);
     }
     else if (b->terrainBrush)
     {
       return Terrain_GetKeyValue(b->pTerrain, pKey);
     }
     else
     {
 		  return ValueForKey(b->epairs, pKey);
     }
 	}
 	else
 	{
 		Sys_Printf("Can only set brush/patch key/values in Brush primitive mode\n");
 	}
   return "";
 }
 
 /*
 =================
 Brush_Write
 save all brushes as Brush primitive format
 =================
 */
 void Brush_Write (brush_t *b, FILE *f)
 {
 	epair_t	*ep;
 	face_t	*fa;
 	char	*pname;
 	int		i;
 	
 	if (b->patchBrush)
 	{
 		Patch_Write(b->pPatch, f);
 		return;
 	}
 	if ( b->pTerrain )
 	{
 		Terrain_Write(b->pTerrain, f);
 		return;
 	}
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
 		// save brush primitive format
 		fprintf (f, "{\nbrushDef\n{\n");
 		// brush epairs
 		if (b->epairs)
 			for (ep = b->epairs ; ep ; ep=ep->next)
 				fprintf (f, "\"%s\" \"%s\"\n", ep->key, ep->value);
 		for (fa=b->brush_faces ; fa ; fa=fa->next)
 		{
 			// save planepts
 			for (i=0 ; i<3 ; i++)
 			{
 				fprintf(f, "( ");
 				for (int j = 0; j < 3; j++)
 					if (fa->planepts[i][j] == static_cast<int>(fa->planepts[i][j]))
 						fprintf(f, "%i ", static_cast<int>(fa->planepts[i][j]));
 					else
 						fprintf(f, "%f ", fa->planepts[i][j]);
 				fprintf(f, ") ");
 			}
 			// save texture coordinates
 			fprintf(f,"( ( ");
 			for (i=0 ; i<3 ; i++)
 				if (fa->brushprimit_texdef.coords[0][i] == static_cast<int>(fa->brushprimit_texdef.coords[0][i]))
 					fprintf(f,"%i ",static_cast<int>(fa->brushprimit_texdef.coords[0][i]));
 				else
 					fprintf(f,"%f ",fa->brushprimit_texdef.coords[0][i]);
 			fprintf(f,") ( ");
 			for (i=0 ; i<3 ; i++)
 				if (fa->brushprimit_texdef.coords[1][i] == static_cast<int>(fa->brushprimit_texdef.coords[1][i]))
 					fprintf(f,"%i ",static_cast<int>(fa->brushprimit_texdef.coords[1][i]));
 				else
 					fprintf(f,"%f ",fa->brushprimit_texdef.coords[1][i]);
 			fprintf(f,") ) ");
 			// save texture attribs
 			//++timo surface properties plugin not implemented for brush primitives
 			if (g_qeglobals.bSurfacePropertiesPlugin)
 				Sys_Printf("WARNING: surface properties plugin not supported with brush primitives (yet)\n");
 
       char *pName = strlen(fa->texdef.name) > 0 ? fa->texdef.name : "unnamed";
 			fprintf(f, "%s ", pName );
 			fprintf(f, "%i %i %i\n", fa->texdef.contents, fa->texdef.flags, fa->texdef.value);
 		}
 		fprintf (f, "}\n}\n");
 	}
 	else
 	{
 		fprintf (f, "{\n");
 		for (fa=b->brush_faces ; fa ; fa=fa->next)
 		{
 			for (i=0 ; i<3 ; i++)
 			{
 				fprintf(f, "( ");
 				for (int j = 0; j < 3; j++)
 				{
 					if (fa->planepts[i][j] == static_cast<int>(fa->planepts[i][j]))
 						fprintf(f, "%i ", static_cast<int>(fa->planepts[i][j]));
 					else
 						fprintf(f, "%f ", fa->planepts[i][j]);
 				}
 				fprintf(f, ") ");
 			}
 			
 			if (g_qeglobals.bSurfacePropertiesPlugin)
 			{
 				g_File = f;
 #ifdef _DEBUG
 				if (!fa->pData)
 					Sys_Printf("ERROR: unexpected IPluginTexdef* is NULL in Brush_Write\n");
 				else
 #endif
 				GETPLUGINTEXDEF(fa)->WriteTexdef( QERApp_MapPrintf_FILE );
 			}
 			else
 			{
 				pname = fa->texdef.name;
 				if (pname[0] == 0)
 					pname = "unnamed";
 				
 				fprintf (f, "%s %i %i %i ", pname,
 					(int)fa->texdef.shift[0], (int)fa->texdef.shift[1],
 					(int)fa->texdef.rotate);
 				
 				if (fa->texdef.scale[0] == (int)fa->texdef.scale[0])
 					fprintf (f, "%i ", (int)fa->texdef.scale[0]);
 				else
 					fprintf (f, "%f ", (float)fa->texdef.scale[0]);
 				if (fa->texdef.scale[1] == (int)fa->texdef.scale[1])
 					fprintf (f, "%i", (int)fa->texdef.scale[1]);
 				else
 					fprintf (f, "%f", (float)fa->texdef.scale[1]);
 				
 				fprintf (f, " %i %i %i", fa->texdef.contents, fa->texdef.flags, fa->texdef.value);
 			}
 			fprintf (f, "\n");
 		}
 		fprintf (f, "}\n");
 	}
 }
 
 /*
 =================
 QERApp_MapPrintf_MEMFILE
 callback for surface properties plugin
 must fit a PFN_QERAPP_MAPPRINTF ( see isurfaceplugin.h )
 =================
 */
 // carefully initialize !
 CMemFile * g_pMemFile;
 void WINAPI QERApp_MapPrintf_MEMFILE( char *text, ... )
 {
 	va_list argptr;
 	char	buf[32768];
 
 	va_start (argptr,text);
 	vsprintf (buf, text,argptr);
 	va_end (argptr);
 
 	MemFile_fprintf( g_pMemFile, buf );
 }
 
 /*
 =================
 Brush_Write to a CMemFile*
 save all brushes as Brush primitive format
 =================
 */
 void Brush_Write (brush_t *b, CMemFile *pMemFile)
 {
 	epair_t *ep;
 	face_t	*fa;
 	char *pname;
 	int		i;
 	
 	if (b->patchBrush)
 	{
 		Patch_Write(b->pPatch, pMemFile);
 		return;
 	}
 	if (b->terrainBrush)
 	{
 		Terrain_Write(b->pTerrain, pMemFile);
 		return;
 	}
 	//++timo NOTE: it's not very difficult to add since the surface properties plugin
 	// writes throught a printf-style function prototype
 	if (g_qeglobals.bSurfacePropertiesPlugin)
 	{
 		Sys_Printf("WARNING: Brush_Write to a CMemFile and Surface Properties plugin not done\n");
 	}
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
 		// brush primitive format
 		MemFile_fprintf (pMemFile, "{\nBrushDef\n{\n");
 		// brush epairs
 		if (b->epairs)
 			for( ep = b->epairs ; ep ; ep=ep->next )
 				MemFile_fprintf (pMemFile, "\"%s\" \"%s\"\n", ep->key, ep->value );
 		for (fa=b->brush_faces ; fa ; fa=fa->next)
 		{
 			// save planepts
 			for (i=0 ; i<3 ; i++)
 			{
 				MemFile_fprintf(pMemFile, "( ");
 				for (int j = 0; j < 3; j++)
 					if (fa->planepts[i][j] == static_cast<int>(fa->planepts[i][j]))
 						MemFile_fprintf(pMemFile, "%i ", static_cast<int>(fa->planepts[i][j]));
 					else
 						MemFile_fprintf(pMemFile, "%f ", fa->planepts[i][j]);
 				MemFile_fprintf(pMemFile, ") ");
 			}
 			// save texture coordinates
 			MemFile_fprintf(pMemFile,"( ( ");
 			for (i=0 ; i<3 ; i++)
 				if (fa->brushprimit_texdef.coords[0][i] == static_cast<int>(fa->brushprimit_texdef.coords[0][i]))
 					MemFile_fprintf(pMemFile,"%i ",static_cast<int>(fa->brushprimit_texdef.coords[0][i]));
 				else
 					MemFile_fprintf(pMemFile,"%f ",fa->brushprimit_texdef.coords[0][i]);
 			MemFile_fprintf(pMemFile,") ( ");
 			for (i=0 ; i<3 ; i++)
 				if (fa->brushprimit_texdef.coords[1][i] == static_cast<int>(fa->brushprimit_texdef.coords[1][i]))
 					MemFile_fprintf(pMemFile,"%i ",static_cast<int>(fa->brushprimit_texdef.coords[1][i]));
 				else
 					MemFile_fprintf(pMemFile,"%f ",fa->brushprimit_texdef.coords[1][i]);
 			MemFile_fprintf(pMemFile,") ) ");
 			// save texture attribs
       char *pName = strlen(fa->texdef.name) > 0 ? fa->texdef.name : "unnamed";
 			MemFile_fprintf(pMemFile, "%s ", pName);
 			MemFile_fprintf(pMemFile, "%i %i %i\n", fa->texdef.contents, fa->texdef.flags, fa->texdef.value);
 		}
 		MemFile_fprintf (pMemFile, "}\n}\n");
 	}
 	else
 	{
 		// old brushes format
 		// also handle surface properties plugin
 		MemFile_fprintf (pMemFile, "{\n");
 		for (fa=b->brush_faces ; fa ; fa=fa->next)
 		{
 			for (i=0 ; i<3 ; i++)
 			{
 				MemFile_fprintf(pMemFile, "( ");
 				for (int j = 0; j < 3; j++)
 				{
 					if (fa->planepts[i][j] == static_cast<int>(fa->planepts[i][j]))
 						MemFile_fprintf(pMemFile, "%i ", static_cast<int>(fa->planepts[i][j]));
 					else
 						MemFile_fprintf(pMemFile, "%f ", fa->planepts[i][j]);
 				}
 				MemFile_fprintf(pMemFile, ") ");
 			}
 			
 			if (g_qeglobals.bSurfacePropertiesPlugin)
 			{
 				g_pMemFile = pMemFile;
 #ifdef _DEBUG
 				if (!fa->pData)
 					Sys_Printf("ERROR: unexpected IPluginTexdef* is NULL in Brush_Write\n");
 				else
 #endif
 				GETPLUGINTEXDEF(fa)->WriteTexdef( QERApp_MapPrintf_MEMFILE );
 			}
 			else
 			{
 				pname = fa->texdef.name;
 				if (pname[0] == 0)
 					pname = "unnamed";
 				
 				MemFile_fprintf (pMemFile, "%s %i %i %i ", pname,
 					(int)fa->texdef.shift[0], (int)fa->texdef.shift[1],
 					(int)fa->texdef.rotate);
 				
 				if (fa->texdef.scale[0] == (int)fa->texdef.scale[0])
 					MemFile_fprintf (pMemFile, "%i ", (int)fa->texdef.scale[0]);
 				else
 					MemFile_fprintf (pMemFile, "%f ", (float)fa->texdef.scale[0]);
 				if (fa->texdef.scale[1] == (int)fa->texdef.scale[1])
 					MemFile_fprintf (pMemFile, "%i", (int)fa->texdef.scale[1]);
 				else
 					MemFile_fprintf (pMemFile, "%f", (float)fa->texdef.scale[1]);
 				
 				MemFile_fprintf (pMemFile, " %i %i %i", fa->texdef.contents, fa->texdef.flags, fa->texdef.value);
 			}
 			MemFile_fprintf (pMemFile, "\n");
 		}
 		MemFile_fprintf (pMemFile, "}\n");
 	}
 	
 	
 }
 
 
 /*
 =============
 Brush_Create
 
 Create non-textured blocks for entities
 The brush is NOT linked to any list
 =============
 */
 brush_t	*Brush_Create (vec3_t mins, vec3_t maxs, texdef_t *texdef)
 {
 	int		i, j;
 	vec3_t	pts[4][2];
 	face_t	*f;
 	brush_t	*b;
 
 	// brush primitive mode : convert texdef to brushprimit_texdef ?
 	// most of the time texdef is empty
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
 		// check texdef is empty .. if there are cases it's not we need to write some conversion code
 		if (texdef->shift[0]!=0 || texdef->shift[1]!=0 || texdef->scale[0]!=0 || texdef->scale[1]!=0 || texdef->rotate!=0)
 			Sys_Printf("Warning : non-zero texdef detected in Brush_Create .. need brush primitive conversion\n");
 	}
 
 	for (i=0 ; i<3 ; i++)
 	{
 		if (maxs[i] < mins[i])
 			Error ("Brush_InitSolid: backwards");
 	}
 
 	b = Brush_Alloc();
 	
 	pts[0][0][0] = mins[0];
 	pts[0][0][1] = mins[1];
 	
 	pts[1][0][0] = mins[0];
 	pts[1][0][1] = maxs[1];
 	
 	pts[2][0][0] = maxs[0];
 	pts[2][0][1] = maxs[1];
 	
 	pts[3][0][0] = maxs[0];
 	pts[3][0][1] = mins[1];
 	
 	for (i=0 ; i<4 ; i++)
 	{
 		pts[i][0][2] = mins[2];
 		pts[i][1][0] = pts[i][0][0];
 		pts[i][1][1] = pts[i][0][1];
 		pts[i][1][2] = maxs[2];
 	}
 
 	for (i=0 ; i<4 ; i++)
 	{
 		f = Face_Alloc();
 		f->texdef = *texdef;
 		f->texdef.flags &= ~SURF_KEEP;
 		f->texdef.contents &= ~CONTENTS_KEEP;
 		f->next = b->brush_faces;
 		b->brush_faces = f;
 		j = (i+1)%4;
 
 		VectorCopy (pts[j][1], f->planepts[0]);
 		VectorCopy (pts[i][1], f->planepts[1]);
 		VectorCopy (pts[i][0], f->planepts[2]);
 	}
 	
 	f = Face_Alloc();
 	f->texdef = *texdef;
 	f->texdef.flags &= ~SURF_KEEP;
 	f->texdef.contents &= ~CONTENTS_KEEP;
 	f->next = b->brush_faces;
 	b->brush_faces = f;
 
 	VectorCopy (pts[0][1], f->planepts[0]);
 	VectorCopy (pts[1][1], f->planepts[1]);
 	VectorCopy (pts[2][1], f->planepts[2]);
 
 	f = Face_Alloc();
 	f->texdef = *texdef;
 	f->texdef.flags &= ~SURF_KEEP;
 	f->texdef.contents &= ~CONTENTS_KEEP;
 	f->next = b->brush_faces;
 	b->brush_faces = f;
 
 	VectorCopy (pts[2][0], f->planepts[0]);
 	VectorCopy (pts[1][0], f->planepts[1]);
 	VectorCopy (pts[0][0], f->planepts[2]);
 
 	return b;
 }
 
 /*
 =============
 Brush_CreatePyramid
 
 Create non-textured pyramid for light entities
 The brush is NOT linked to any list
 =============
 */
 brush_t	*Brush_CreatePyramid (vec3_t mins, vec3_t maxs, texdef_t *texdef)
 {
 	//++timo handle new brush primitive ? return here ??
 	return Brush_Create(mins, maxs, texdef);
 
 	for (int i=0 ; i<3 ; i++)
 		if (maxs[i] < mins[i])
 			Error ("Brush_InitSolid: backwards");
 
 	brush_t* b = Brush_Alloc();
 
 	vec3_t corners[4];
 
 	float fMid = Q_rint(mins[2] + (Q_rint((maxs[2] - mins[2]) / 2)));
 
 	corners[0][0] = mins[0];
 	corners[0][1] = mins[1];
 	corners[0][2] = fMid;
 
 	corners[1][0] = mins[0];
 	corners[1][1] = maxs[1];
 	corners[1][2] = fMid;
 
 	corners[2][0] = maxs[0];
 	corners[2][1] = maxs[1];
 	corners[2][2] = fMid;
 
 	corners[3][0] = maxs[0];
 	corners[3][1] = mins[1];
 	corners[3][2] = fMid;
 
 	vec3_t top, bottom;
 
 	top[0] = Q_rint(mins[0] + ((maxs[0] - mins[0]) / 2));
 	top[1] = Q_rint(mins[1] + ((maxs[1] - mins[1]) / 2));
 	top[2] = Q_rint(maxs[2]);
 
 	VectorCopy(top, bottom);
 	bottom[2] = mins[2];
 
 	// sides
 	for (i = 0; i < 4; i++)
 	{
 		face_t* f = Face_Alloc();
 		f->texdef = *texdef;
 		f->texdef.flags &= ~SURF_KEEP;
 		f->texdef.contents &= ~CONTENTS_KEEP;
 		f->next = b->brush_faces;
 		b->brush_faces = f;
 		int j = (i+1)%4;
 
 		VectorCopy (top, f->planepts[0]);
 		VectorCopy (corners[i], f->planepts[1]);
 		VectorCopy(corners[j], f->planepts[2]);
 
 		f = Face_Alloc();
 		f->texdef = *texdef;
 		f->texdef.flags &= ~SURF_KEEP;
 		f->texdef.contents &= ~CONTENTS_KEEP;
 		f->next = b->brush_faces;
 		b->brush_faces = f;
 
 		VectorCopy (bottom, f->planepts[2]);
 		VectorCopy (corners[i], f->planepts[1]);
 		VectorCopy(corners[j], f->planepts[0]);
 	}
 
 	return b;
 }
 
 
 
 
 /*
 =============
 Brush_MakeSided
 
 Makes the current brush have the given number of 2d sides
 =============
 */
 void Brush_MakeSided (int sides)
 {
 	int		i, axis;
 	vec3_t	mins, maxs;
 	brush_t	*b;
 	texdef_t	*texdef;
 	face_t	*f;
 	vec3_t	mid;
 	float	width;
 	float	sv, cv;
 
 	if (sides < 3)
 	{
 		Sys_Status ("Bad sides number", 0);
 		return;
 	}
 
 	if (sides >= MAX_POINTS_ON_WINDING-4)
 	{
 		Sys_Printf("too many sides.\n");
 		return;
 	}
 
 	if (!QE_SingleBrush ())
 	{
 		Sys_Status ("Must have a single brush selected", 0 );
 		return;
 	}
 
 	b = selected_brushes.next;
 	VectorCopy (b->mins, mins);
 	VectorCopy (b->maxs, maxs);
 	texdef = &g_qeglobals.d_texturewin.texdef;
 
 	Brush_Free (b);
 
 	if (g_pParentWnd->ActiveXY())
 	{
 		switch(g_pParentWnd->ActiveXY()->GetViewType())
 		{
 			case XY: axis = 2; break;
 			case XZ: axis = 1; break;
 			case YZ: axis = 0; break;
 		}
 	}
 	else
 	{
 		axis = 2;
 	}
 
 	// find center of brush
 	width = 8;
 	for (i = 0; i < 3; i++)
 	{
 		mid[i] = (maxs[i] + mins[i]) * 0.5;
 		if (i == axis) continue;
 		if ((maxs[i] - mins[i]) * 0.5 > width)
 			width = (maxs[i] - mins[i]) * 0.5;
 	}
 
 	b = Brush_Alloc();
 		
 	// create top face
 	f = Face_Alloc();
 	f->texdef = *texdef;
 	f->next = b->brush_faces;
 	b->brush_faces = f;
 
 	f->planepts[2][(axis+1)%3] = mins[(axis+1)%3]; f->planepts[2][(axis+2)%3] = mins[(axis+2)%3]; f->planepts[2][axis] = maxs[axis];
 	f->planepts[1][(axis+1)%3] = maxs[(axis+1)%3]; f->planepts[1][(axis+2)%3] = mins[(axis+2)%3]; f->planepts[1][axis] = maxs[axis];
 	f->planepts[0][(axis+1)%3] = maxs[(axis+1)%3]; f->planepts[0][(axis+2)%3] = maxs[(axis+2)%3]; f->planepts[0][axis] = maxs[axis];
 
 	// create bottom face
 	f = Face_Alloc();
 	f->texdef = *texdef;
 	f->next = b->brush_faces;
 	b->brush_faces = f;
 
 	f->planepts[0][(axis+1)%3] = mins[(axis+1)%3]; f->planepts[0][(axis+2)%3] = mins[(axis+2)%3]; f->planepts[0][axis] = mins[axis];
 	f->planepts[1][(axis+1)%3] = maxs[(axis+1)%3]; f->planepts[1][(axis+2)%3] = mins[(axis+2)%3]; f->planepts[1][axis] = mins[axis];
 	f->planepts[2][(axis+1)%3] = maxs[(axis+1)%3]; f->planepts[2][(axis+2)%3] = maxs[(axis+2)%3]; f->planepts[2][axis] = mins[axis];
 
 	for (i=0 ; i<sides ; i++)
 	{
 		f = Face_Alloc();
 		f->texdef = *texdef;
 		f->next = b->brush_faces;
 		b->brush_faces = f;
 
 		sv = sin (i*3.14159265*2/sides);
 		cv = cos (i*3.14159265*2/sides);
 
 		f->planepts[0][(axis+1)%3] = floor(mid[(axis+1)%3]+width*cv+0.5);
 		f->planepts[0][(axis+2)%3] = floor(mid[(axis+2)%3]+width*sv+0.5);
 		f->planepts[0][axis] = mins[axis];
 
 		f->planepts[1][(axis+1)%3] = f->planepts[0][(axis+1)%3];
 		f->planepts[1][(axis+2)%3] = f->planepts[0][(axis+2)%3];
 		f->planepts[1][axis] = maxs[axis];
 
 		f->planepts[2][(axis+1)%3] = floor(f->planepts[0][(axis+1)%3] - width*sv + 0.5);
 		f->planepts[2][(axis+2)%3] = floor(f->planepts[0][(axis+2)%3] + width*cv + 0.5);
 		f->planepts[2][axis] = maxs[axis];
 	}
 
 	Brush_AddToList (b, &selected_brushes);
 
 	Entity_LinkBrush (world_entity, b);
 
 	Brush_Build( b );
 
 	Sys_UpdateWindows (W_ALL);
 }
 
 
 
 /*
 =============
 Brush_Free
 
 Frees the brush with all of its faces and display list.
 Unlinks the brush from whichever chain it is in.
 Decrements the owner entity's brushcount.
 Removes owner entity if this was the last brush
 unless owner is the world.
 Removes from groups
 =============
 */
 void Brush_Free (brush_t *b, bool bRemoveNode)
 {
 	face_t	*f, *next;
 	epair_t	*ep, *enext;
 
 	// remove from group
 	if (bRemoveNode)
 		Group_RemoveBrush(b);
 
 	// free the patch if it's there
 	if (b->patchBrush)
 	{
 		Patch_Delete(b->pPatch);
 	}
 
 	if( b->terrainBrush )
 	{
 		Terrain_Delete( b->pTerrain );
 	}
 
 	// free faces
 	for (f=b->brush_faces ; f ; f=next)
 	{
 		next = f->next;
 		Face_Free( f );
 	}
 
 	//Timo : free brush epairs
 	for (ep = b->epairs ; ep ; ep=enext )
 	{
 		enext = ep->next;
 		free (ep->key);
 		free (ep->value);
 		free (ep);
 	}
 
 	// unlink from active/selected list
 	if (b->next)
 		Brush_RemoveFromList (b);
 
 	// unlink from entity list
 	if (b->onext)
 		Entity_UnlinkBrush (b);
 
 	free (b);
 }
 
 /*
 =============
 Face_MemorySize
 =============
 */
 int Face_MemorySize(face_t *f )
 {
 	int size = 0;
 
 	if (f->face_winding)
 	{
 		size += _msize(f->face_winding);
 	}
 	//f->texdef.~texdef_t();;
 	size += _msize(f);
 	return size;
 }
 
 /*
 =============
 Brush_MemorySize
 =============
 */
 int Brush_MemorySize(brush_t *b)
 {
 	face_t	*f;
 	epair_t	*ep;
 	int size = 0;
 
 	//
 	if (b->patchBrush)
 	{
 		size += Patch_MemorySize(b->pPatch);
 	}
 	if (b->terrainBrush)
 	{
 		size += Terrain_MemorySize(b->pTerrain);
 	}
 	//
 	for (f = b->brush_faces; f; f = f->next)
 	{
 		size += Face_MemorySize(f);
 	}
 	//
 	for (ep = b->epairs; ep; ep = ep->next )
 	{
 		size += _msize(ep->key);
 		size += _msize(ep->value);
 		size += _msize(ep);
 	}
 	size += _msize(b);
 	return size;
 }
 
 
 /*
 ============
 Brush_Clone
 
 Does NOT add the new brush to any lists
 ============
 */
 brush_t *Brush_Clone (brush_t *b)
 {
 	brush_t	*n = NULL;
 	face_t	*f, *nf;
 
 	if (b->patchBrush)
 	{
 		patchMesh_t *p = Patch_Duplicate(b->pPatch);
 		Brush_RemoveFromList(p->pSymbiot);
 		Entity_UnlinkBrush(p->pSymbiot);
 		n = p->pSymbiot;
 	}
 	else if (b->terrainBrush)
 	{
 		terrainMesh_t *p = Terrain_Duplicate(b->pTerrain);
 		Brush_RemoveFromList(p->pSymbiot);
 		Entity_UnlinkBrush(p->pSymbiot);
 		n = p->pSymbiot;
 	}
 	else
 	{
   	n = Brush_Alloc();
 	  n->numberId = g_nBrushId++;
 		n->owner = b->owner;
 		for (f=b->brush_faces ; f ; f=f->next)
 		{
 			nf = Face_Clone( f );
 			nf->next = n->brush_faces;
 			n->brush_faces = nf;
 		}
 	}
 
 	return n;
 }
 
 
 
 /*
 ============
 Brush_Clone
 
 Does NOT add the new brush to any lists
 ============
 */
 brush_t *Brush_FullClone(brush_t *b)
 {
 	brush_t	*n = NULL;
 	face_t *f, *nf, *f2, *nf2;
 	int j;
 
 	if (b->patchBrush)
 	{
 		patchMesh_t *p = Patch_Duplicate(b->pPatch);
 		Brush_RemoveFromList(p->pSymbiot);
 		Entity_UnlinkBrush(p->pSymbiot);
 		n = p->pSymbiot;
 		n->owner = b->owner;
 		Brush_Build(n);
 	}
 	else if (b->terrainBrush)
 	{
 		terrainMesh_t *p = Terrain_Duplicate(b->pTerrain);
 		Brush_RemoveFromList(p->pSymbiot);
 		Entity_UnlinkBrush(p->pSymbiot);
 		n = p->pSymbiot;
 		n->owner = b->owner;
 		Brush_Build(n);
 	}
 	else
 	{
   	n = Brush_Alloc();
    	n->numberId = g_nBrushId++;
 		n->owner = b->owner;
 		VectorCopy(b->mins, n->mins);
 		VectorCopy(b->maxs, n->maxs);
 		//
 		for (f = b->brush_faces; f; f = f->next)
 		{
 			if (f->original) continue;
 			nf = Face_FullClone(f);
 			nf->next = n->brush_faces;
 			n->brush_faces = nf;
 			//copy all faces that have the original set to this face
 			for (f2 = b->brush_faces; f2; f2 = f2->next)
 			{
 				if (f2->original == f)
 				{
 					nf2 = Face_FullClone(f2);
 					nf2->next = n->brush_faces;
 					n->brush_faces = nf2;
 					//set original
 					nf2->original = nf;
 				}
 			}
 		}
 		for (nf = n->brush_faces; nf; nf = nf->next)
 		{
 			Face_SetColor(n, nf, 1.0);
 			if (nf->face_winding)
       {
         if (g_qeglobals.m_bBrushPrimitMode)
     			EmitBrushPrimitTextureCoordinates(nf,nf->face_winding);
         else
         {
 				  for (j = 0; j < nf->face_winding->numpoints; j++)
   					EmitTextureCoordinates(nf->face_winding->points[j], nf->d_texture, nf);
         }
       }
 		}
   }
 	return n;
 }
 
 /*
 ==============
 Brush_Ray
 
 Itersects a ray with a brush
 Returns the face hit and the distance along the ray the intersection occured at
 Returns NULL and 0 if not hit at all
 ==============
 */
 face_t *Brush_Ray (vec3_t origin, vec3_t dir, brush_t *b, float *dist)
 {
 	face_t	*f, *firstface;
 	vec3_t	p1, p2;
 	float	frac, d1, d2;
 	int		i;
 
 	VectorCopy (origin, p1);
 	for (i=0 ; i<3 ; i++)
 		p2[i] = p1[i] + dir[i]*16384;
 
 	for (f=b->brush_faces ; f ; f=f->next)
 	{
 		d1 = DotProduct (p1, f->plane.normal) - f->plane.dist;
 		d2 = DotProduct (p2, f->plane.normal) - f->plane.dist;
 		if (d1 >= 0 && d2 >= 0)
 		{
 			*dist = 0;
 			return NULL;	// ray is on front side of face
 		}
 		if (d1 <=0 && d2 <= 0)
 			continue;
 	// clip the ray to the plane
 		frac = d1 / (d1 - d2);
 		if (d1 > 0)
 		{
 			firstface = f;
 			for (i=0 ; i<3 ; i++)
 				p1[i] = p1[i] + frac *(p2[i] - p1[i]);
 		}
 		else
 		{
 			for (i=0 ; i<3 ; i++)
 				p2[i] = p1[i] + frac *(p2[i] - p1[i]);
 		}
 	}
 
 	// find distance p1 is along dir
 	VectorSubtract (p1, origin, p1);
 	d1 = DotProduct (p1, dir);
 
 	*dist = d1;
 
 	return firstface;
 }
 
 //PGM
 face_t *Brush_Point (vec3_t origin, brush_t *b)
 {
 	face_t	*f;
 	float	d1;
 
 	for (f=b->brush_faces ; f ; f=f->next)
 	{
 		d1 = DotProduct (origin, f->plane.normal) - f->plane.dist;
 		if (d1 > 0)
 		{
 			return NULL;	// point is on front side of face
 		}
 	}
 
 	return b->brush_faces;
 }
 //PGM
 
 
 void	Brush_AddToList (brush_t *b, brush_t *list)
 {
 	if (b->next || b->prev)
 		Error ("Brush_AddToList: allready linked");
 	
 	if (list == &selected_brushes || list == &active_brushes)
 	{
 		if (b->patchBrush && list == &selected_brushes)
 		{
 			Patch_Select(b->pPatch);
 		}
 		if (b->terrainBrush && list == &selected_brushes) {
 			Terrain_Select(b->pTerrain);
 		}
 	}
 	b->next = list->next;
 	list->next->prev = b;
 	list->next = b;
 	b->prev = list;
 	
 	// TTimo messaging
 	DispatchRadiantMsg( RADIANT_SELECTION );	
 }
 
 void	Brush_RemoveFromList (brush_t *b)
 {
 	if (!b->next || !b->prev)
 		Error ("Brush_RemoveFromList: not linked");
 	
 	if (b->patchBrush)
 	{
 		Patch_Deselect(b->pPatch);
 		//Patch_Deselect(b->nPatchID);
 	}
 	if (b->terrainBrush)
 	{
 		Terrain_Deselect(b->pTerrain);
 	}
 
 	b->next->prev = b->prev;
 	b->prev->next = b->next;
 	b->next = b->prev = NULL;
 }
 
 /*
 ===============
 SetFaceTexdef
 
 Doesn't set the curve flags
 
 NOTE : ( TTimo )
 	never trust f->d_texture here, f->texdef and f->d_texture are out of sync when called by Brush_SetTexture
 	use Texture_ForName() to find the right shader
 	FIXME : send the right shader ( qtexture_t * ) in the parameters ?
 
 TTimo: surface plugin, added an IPluginTexdef* parameter
 		if not NULL, get ->Copy() of it into the face ( and remember to hook )
 		if NULL, ask for a default
 ===============
 */
 void SetFaceTexdef (brush_t *b, face_t *f, texdef_t *texdef, brushprimit_texdef_t *brushprimit_texdef, bool bFitScale, IPluginTexdef* pPlugTexdef) {
 	int		oldFlags;
 	int		oldContents;
 	face_t	*tf;
 
 	oldFlags = f->texdef.flags;
 	oldContents = f->texdef.contents;
 	if (g_qeglobals.m_bBrushPrimitMode)
 	{
 		f->texdef = *texdef;
 		ConvertTexMatWithQTexture( brushprimit_texdef, NULL, &f->brushprimit_texdef, Texture_ForName( f->texdef.name ) );
 	}
 	else
 		if (bFitScale)
 		{
 			f->texdef = *texdef;
 			// fit the scaling of the texture on the actual plane
 			vec3_t p1,p2,p3; // absolute coordinates
 			// compute absolute coordinates
 			ComputeAbsolute(f,p1,p2,p3);
 			// compute the scale
 			vec3_t vx,vy;
 			VectorSubtract(p2,p1,vx);
 			VectorNormalize(vx);
 			VectorSubtract(p3,p1,vy);
 			VectorNormalize(vy);
 			// assign scale
 			VectorScale(vx,texdef->scale[0],vx);
 			VectorScale(vy,texdef->scale[1],vy);
 			VectorAdd(p1,vx,p2);
 			VectorAdd(p1,vy,p3);
 			// compute back shift scale rot
 			AbsoluteToLocal(f->plane,f,p1,p2,p3);
 		}
 		else
 			f->texdef = *texdef;
 	f->texdef.flags = (f->texdef.flags & ~SURF_KEEP) | (oldFlags & SURF_KEEP);
 	f->texdef.contents = (f->texdef.contents & ~CONTENTS_KEEP) | (oldContents & CONTENTS_KEEP);
 
 	// surface plugin
 	if (g_qeglobals.bSurfacePropertiesPlugin)
 	{
 #ifdef _DEBUG
 		if (!f->pData)
 			Sys_Printf("ERROR: unexpected IPluginTexdef* is NULL in SetFaceTexdef\n");
 		else
 #endif
 			GETPLUGINTEXDEF(f)->DecRef();
 		IPluginTexdef *pTexdef = NULL;
 		if ( pPlugTexdef )
 		{
 			pTexdef = pPlugTexdef->Copy();
 			pTexdef->Hook( f );
 		}
 		else
 			pTexdef = g_SurfaceTable.m_pfnTexdefAlloc( f );
 		f->pData = pTexdef;
 	}
 
 	// if this is a curve face, set all other curve faces to the same texdef
 	if (f->texdef.flags & SURF_CURVE) 
 	{
 		for (tf = b->brush_faces ; tf ; tf = tf->next) 
 		{
 			if (tf->texdef.flags & SURF_CURVE) 
 				tf->texdef = f->texdef;
 		}
 	}
 }
 
 
 void Brush_SetTexture (brush_t *b, texdef_t *texdef, brushprimit_texdef_t *brushprimit_texdef, bool bFitScale, IPluginTexdef* pTexdef)
 {
 	for (face_t* f = b->brush_faces ; f ; f = f->next) 
 	{
 		SetFaceTexdef (b, f, texdef, brushprimit_texdef, bFitScale, pTexdef);
 	}
 	Brush_Build( b );
 	if (b->patchBrush)
 	{
 		//++timo clean
 //		Sys_Printf("WARNING: Brush_SetTexture needs surface plugin code for patches\n");
 		Patch_SetTexture(b->pPatch, texdef, pTexdef );
 	}
 	if (b->terrainBrush)
 	{
 		Terrain_SetTexture(b->pTerrain, texdef);
 	}
 
 }
 
 
 qboolean ClipLineToFace (vec3_t p1, vec3_t p2, face_t *f)
 {
 	float	d1, d2, fr;
 	int		i;
 	float	*v;
 
 	d1 = DotProduct (p1, f->plane.normal) - f->plane.dist;
 	d2 = DotProduct (p2, f->plane.normal) - f->plane.dist;
 
 	if (d1 >= 0 && d2 >= 0)
 		return false;		// totally outside
 	if (d1 <= 0 && d2 <= 0)
 		return true;		// totally inside
 
 	fr = d1 / (d1 - d2);
 
 	if (d1 > 0)
 		v = p1;
 	else
 		v = p2;
 
 	for (i=0 ; i<3 ; i++)
 		v[i] = p1[i] + fr*(p2[i] - p1[i]);
 
 	return true;
 }
 
 
 int AddPlanept (float *f)
 {
 	int		i;
 
 	for (i=0 ; i<g_qeglobals.d_num_move_points ; i++)
 		if (g_qeglobals.d_move_points[i] == f)
 			return 0;
 	g_qeglobals.d_move_points[g_qeglobals.d_num_move_points++] = f;
 	return 1;
 }
 
 /*
 ==============
 Brush_SelectFaceForDragging
 
 Adds the faces planepts to move_points, and
 rotates and adds the planepts of adjacent face if shear is set
 ==============
 */
 void Brush_SelectFaceForDragging (brush_t *b, face_t *f, qboolean shear)
 {
 	int		i;
 	face_t	*f2;
 	winding_t	*w;
 	float	d;
 	brush_t	*b2;
 	int		c;
 
 	if (b->owner->eclass->fixedsize)
 		return;
 
 	c = 0;
 	for (i=0 ; i<3 ; i++)
 		c += AddPlanept (f->planepts[i]);
 	if (c == 0)
 		return;		// allready completely added
 
 	// select all points on this plane in all brushes the selection
 	for (b2=selected_brushes.next ; b2 != &selected_brushes ; b2 = b2->next)
 	{
 		if (b2 == b)
 			continue;
 		for (f2=b2->brush_faces ; f2 ; f2=f2->next)
 		{
 			for (i=0 ; i<3 ; i++)
 				if (fabs(DotProduct(f2->planepts[i], f->plane.normal)
 				-f->plane.dist) > ON_EPSILON)
 					break;
 			if (i==3)
 			{	// move this face as well
 				Brush_SelectFaceForDragging (b2, f2, shear);
 				break;
 			}
 		}
 	}
 
 
 	// if shearing, take all the planes adjacent to 
 	// selected faces and rotate their points so the
 	// edge clipped by a selcted face has two of the points
 	if (!shear)
 		return;
 
 	for (f2=b->brush_faces ; f2 ; f2=f2->next)
 	{
 		if (f2 == f)
 			continue;
 		w = Brush_MakeFaceWinding (b, f2);
 		if (!w)
 			continue;
 
 		// any points on f will become new control points
 		for (i=0 ; i<w->numpoints ; i++)
 		{
 			d = DotProduct (w->points[i], f->plane.normal) 
 				- f->plane.dist;
 			if (d > -ON_EPSILON && d < ON_EPSILON)
 				break;
 		}
 
 		//
 		// if none of the points were on the plane,
 		// leave it alone
 		//
 		if (i != w->numpoints)
 		{
 			if (i == 0)
 			{	// see if the first clockwise point was the
 				// last point on the winding
 				d = DotProduct (w->points[w->numpoints-1]
 					, f->plane.normal) - f->plane.dist;
 				if (d > -ON_EPSILON && d < ON_EPSILON)
 					i = w->numpoints - 1;
 			}
 
 			AddPlanept (f2->planepts[0]);
 
 			VectorCopy (w->points[i], f2->planepts[0]);
 			if (++i == w->numpoints)
 				i = 0;
 			
 			// see if the next point is also on the plane
 			d = DotProduct (w->points[i]
 				, f->plane.normal) - f->plane.dist;
 			if (d > -ON_EPSILON && d < ON_EPSILON)
 				AddPlanept (f2->planepts[1]);
 
 			VectorCopy (w->points[i], f2->planepts[1]);
 			if (++i == w->numpoints)
 				i = 0;
 
 			// the third point is never on the plane
 
 			VectorCopy (w->points[i], f2->planepts[2]);
 		}
 
 		free(w);
 	}
 }
 
 /*
 ==============
 Brush_SideSelect
 
 The mouse click did not hit the brush, so grab one or more side
 planes for dragging
 ==============
 */
 void Brush_SideSelect (brush_t *b, vec3_t origin, vec3_t dir
 					   , qboolean shear)
 {
 	face_t	*f, *f2;
 	vec3_t	p1, p2;
 
   //if (b->patchBrush)
   //  return;
     //Patch_SideSelect(b->nPatchID, origin, dir);
 	for (f=b->brush_faces ; f ; f=f->next)
 	{
 		VectorCopy (origin, p1);
 		VectorMA (origin, 16384, dir, p2);
 
 		for (f2=b->brush_faces ; f2 ; f2=f2->next)
 		{
 			if (f2 == f)
 				continue;
 			ClipLineToFace (p1, p2, f2);
 		}
 
 		if (f2)
 			continue;
 
 		if (VectorCompare (p1, origin))
 			continue;
 		if (ClipLineToFace (p1, p2, f))
 			continue;
 
 		Brush_SelectFaceForDragging (b, f, shear);
 	}
 
 	
 }
 
 void Brush_BuildWindings( brush_t *b, bool bSnap )
 {
 	winding_t *w;
 	face_t    *face;
 	vec_t      v;
 
 	if (bSnap)
 		Brush_SnapPlanepts( b );
 
 	// clear the mins/maxs bounds
 	b->mins[0] = b->mins[1] = b->mins[2] = 99999;
 	b->maxs[0] = b->maxs[1] = b->maxs[2] = -99999;
 
 	Brush_MakeFacePlanes (b);
 
 	face = b->brush_faces;
 
 	float fCurveColor = 1.0;
 
 	for ( ; face ; face=face->next)
 	{
 		int i, j;
 		free(face->face_winding);
 		w = face->face_winding = Brush_MakeFaceWinding (b, face);
 		face->d_texture = Texture_ForName( face->texdef.name );
 
 		if (!w)
 			continue;
 	
 		for (i=0 ; i<w->numpoints ; i++)
 		{
 			// add to bounding box
 			for (j=0 ; j<3 ; j++)
 			{
 				v = w->points[i][j];
 				if (v > b->maxs[j])
 					b->maxs[j] = v;
 				if (v < b->mins[j])
 					b->mins[j] = v;
 			}
 		}
 		// setup s and t vectors, and set color
 		//if (!g_PrefsDlg.m_bGLLighting)
     //{
 		  Face_SetColor (b, face, fCurveColor);
     //}
 
 		fCurveColor -= .10;
 		if (fCurveColor <= 0)
 			fCurveColor = 1.0;
 
 		// computing ST coordinates for the windings
 		if (g_qeglobals.m_bBrushPrimitMode)
 		{
 			if (g_qeglobals.bNeedConvert)
 			{
 				// we have parsed old brushes format and need conversion
 				// convert old brush texture representation to new format
 				FaceToBrushPrimitFace(face);
 #ifdef _DEBUG
 				// use old texture coordinates code to check against
 			    for (i=0 ; i<w->numpoints ; i++)
 					EmitTextureCoordinates( w->points[i], face->d_texture, face);
 #endif
 			}
 			// use new texture representation to compute texture coordinates
 			// in debug mode we will check against old code and warn if there are differences
 			EmitBrushPrimitTextureCoordinates(face,w);
 		}
 		else
 		{
 		    for (i=0 ; i<w->numpoints ; i++)
 				EmitTextureCoordinates( w->points[i], face->d_texture, face);
 		}
 	}
 }
 
 /*
 ==================
 Brush_RemoveEmptyFaces
 
 Frees any overconstraining faces
 ==================
 */
 void Brush_RemoveEmptyFaces ( brush_t *b )
 {
 	face_t	*f, *next;
 
 	f = b->brush_faces;
 	b->brush_faces = NULL;
 
 	for ( ; f ; f=next)
 	{
 		next = f->next;
 		if (!f->face_winding)
 			Face_Free (f);
 		else
 		{
 			f->next = b->brush_faces;
 			b->brush_faces = f;
 		}
 
 	}
 }
 
 void Brush_SnapToGrid(brush_t *pb)
 {
 	for (face_t *f = pb->brush_faces ; f; f = f->next)
 	{
 		for (int i = 0 ;i < 3 ;i++)
 		{
 			for (int j = 0 ;j < 3 ; j++)
 			{
 				f->planepts[i][j] = floor (f->planepts[i][j] / g_qeglobals.d_gridsize + 0.5) * g_qeglobals.d_gridsize;
 			}
 		}
 	}
 	Brush_Build(pb);
 }
 
 void Brush_Rotate(brush_t *b, vec3_t vAngle, vec3_t vOrigin, bool bBuild)
 {
 	for (face_t* f=b->brush_faces ; f ; f=f->next)
 	{
 		for (int i=0 ; i<3 ; i++)
 		{
 			VectorRotate(f->planepts[i], vAngle, vOrigin, f->planepts[i]);
 		}
 	}
 	if (bBuild)
 	{
 		Brush_Build(b, false, false);
 	}
 }
 
 void Brush_Center(brush_t *b, vec3_t vNewCenter)
 {
   vec3_t vMid;
   // get center of the brush
   for (int j = 0; j < 3; j++)
   {
     vMid[j] = b->mins[j] + abs((b->maxs[j] - b->mins[j]) * 0.5);
   }
   // calc distance between centers
   VectorSubtract(vNewCenter, vMid, vMid);
   Brush_Move(b, vMid, true);
 
 }
 
 // only designed for fixed size entity brushes
 void Brush_Resize(brush_t *b, vec3_t vMin, vec3_t vMax)
 {
   brush_t *b2 = Brush_Create(vMin, vMax, &b->brush_faces->texdef);
 
   face_t *next;
 	for (face_t *f=b->brush_faces ; f ; f=next)
 	{
 		next = f->next;
 		Face_Free( f );
 	}
 
   b->brush_faces = b2->brush_faces;
 
 	// unlink from active/selected list
 	if (b2->next)
   Brush_RemoveFromList (b2);
   free(b2);
   Brush_Build(b, true);
 }
 
 
 eclass_t* HasModel(brush_t *b)
 {
   vec3_t vMin, vMax;
   vMin[0] = vMin[1] = vMin[2] = 9999;
   vMax[0] = vMax[1] = vMax[2] = -9999;
 
   if (b->owner->md3Class != NULL)
   {
     return b->owner->md3Class;
   }
 
   if (Eclass_hasModel(b->owner->eclass, vMin, vMax))
   {
     return b->owner->eclass;
   }
 
   eclass_t *e = NULL;
   // FIXME: entity needs to track whether a cache hit failed and not ask again
   if (b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)
   {
     char *pModel = ValueForKey(b->owner, "model");
     if (pModel != NULL && strlen(pModel) > 0)
     {
       e = GetCachedModel(b->owner, pModel, vMin, vMax);
       if (e != NULL)
       {
         // we need to scale the brush to the proper size based on the model load
         // recreate brush just like in load/save
 
 		    VectorAdd (vMin, b->owner->origin, vMin);
 		    VectorAdd (vMax, b->owner->origin, vMax);
 
         Brush_Resize(b, vMin, vMax);
 
 /*
         //
         vec3_t vTemp, vTemp2;
         VectorSubtract(b->maxs, b->mins, vTemp);
         VectorSubtract(vMax, vMin, vTemp2);
         for (int i = 0; i < 3; i++)
         {
           if (vTemp[i] != 0)
           {
             vTemp2[i] /= vTemp[i];
           }
         }
         vec3_t vMid, vMid2;
         vMid[0] = vMid[1] = vMid[2] = 0.0;
         vMid2[0] = vMid2[1] = vMid2[2] = 0.0;
 
         for (int j = 0; j < 3; j++)
         {
           vMid2[j] = b->mins[j] + abs((b->maxs[j] - b->mins[j]) * 0.5);
         }
 
         //VectorSubtract(vMid2, vMid, vMid2);
 
 		    for (face_t* f=b->brush_faces ; f ; f=f->next)
 		    {
 			    for (int i=0 ; i<3 ; i++)
 			    {
 
             // scale
             VectorSubtract(f->planepts[i], vMid2, f->planepts[i]);
             f->planepts[i][0] *= vTemp2[0];
             f->planepts[i][1] *= vTemp2[1];
             f->planepts[i][2] *= vTemp2[2];
             VectorAdd(f->planepts[i], vMid2, f->planepts[i]);
           }
         }
 
         //Brush_Center(b, b->owner->origin);
 
         //Brush_SnapToGrid(b);
 /*
         float a = FloatForKey (b->owner, "angle");
         if (a)
         {
           vec3_t vAngle;
           vAngle[0] = vAngle[1] = 0;
           vAngle[2] = a;
           Brush_Rotate(b, vAngle, b->owner->origin);
         }
         else
         {
           Brush_Build(b, true);
 */
 //        }
 
         b->bModelFailed = false;
       }
       else
       {
         b->bModelFailed = true;
       }
     } 
   }
   return e;
 }
 
 static bool g_bInPaintedModel = false;
 static bool g_bDoIt = false;
 bool PaintedModel(brush_t *b, bool bOkToTexture)
 {
     if (g_bInPaintedModel)
     { 
       return true;
     }
     
     if (g_PrefsDlg.m_nEntityShowState == ENTITY_BOX || b->bModelFailed)
     {
       return false;
     }
     else if (!IsBrushSelected(b) && (g_PrefsDlg.m_nEntityShowState & ENTITY_SELECTED_ONLY))
     {
 	    return false;
     }
 
     g_bInPaintedModel = true;
     bool bReturn = false;
 
     eclass_t *pEclass = HasModel(b);
 
     if (pEclass)
     {
       qglPushAttrib(GL_ALL_ATTRIB_BITS);
       entitymodel *model = pEclass->model;
 
 
       float a = FloatForKey (b->owner, "angle");
       while (model != NULL)
       {
         if (bOkToTexture == false || g_PrefsDlg.m_nEntityShowState & ENTITY_WIREFRAME || model->nTextureBind == -1)	// skinned
         {
 	        qglDisable( GL_CULL_FACE );
 	        qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 	        qglDisable(GL_TEXTURE_2D);
           qglColor3fv(pEclass->color);
         }
         else
         {
           qglColor3f(1, 1, 1);
           qglEnable(GL_TEXTURE_2D);
 	        qglBindTexture( GL_TEXTURE_2D, model->nTextureBind );
         }
         vec3_t v;
         
         int i,j;
         VectorAdd(b->maxs, b->mins, v);
         VectorScale(v, 0.5, v);
         VectorCopy(b->owner->origin, v);
 
 	      
         //for (i = 0; i < 3; i++)
         //{
         //  v[i] -= (pEclass->mins[i] - b->mins[i]);
         //}
 
         //if (model->nModelPosition)
         //{
 		      //v[2] = b->mins[2] - (pEclass->mins[2]);
         //}
 
         float s, c;
 	      if (a)
         {
 		      s = sin (a/180*Q_PI);
 		      c = cos (a/180*Q_PI);
         }
 
         vec3_t vSin;
         vec3_t vCos;
         VectorClear(vSin);
         VectorClear(vCos);
         for ( j = 0; j < 3; j++)
         {
           if (b->owner->vRotation[j])
           {
             vSin[j] = sin(b->owner->vRotation[j]/180*Q_PI);
             vCos[j] = cos(b->owner->vRotation[j]/180*Q_PI);
           }
         }
 
 
 	      qglBegin (GL_TRIANGLES);
 
         vec5_t vTest[3];
         for (i = 0; i < model->nTriCount; i++)
         {
           for (j = 0; j < 3; j++)
           {
 #if 1
             float x = model->pTriList[i].v[j][0] + v[0];
             float y = model->pTriList[i].v[j][1] + v[1];
             if (a)
             {
               float x2 = (((x - v[0]) * c) - ((y - v[1]) * s)) + v[0];
               float y2 = (((x - v[0]) * s) + ((y - v[1]) * c)) + v[1];
               x = x2;
               y = y2;
             }
             //qglTexCoord2f (pEclass->pTriList[i].st[j][0] / pEclass->nSkinWidth, pEclass->pTriList[i].st[j][1] / pEclass->nSkinHeight);
             qglTexCoord2f (model->pTriList[i].st[j][0], model->pTriList[i].st[j][1]);
             qglVertex3f(x, y, model->pTriList[i].v[j][2] + v[2]);
 #else
             float x = model->pTriList[i].v[j][0] + v[0];
             float y = model->pTriList[i].v[j][1] + v[1];
             float z = model->pTriList[i].v[j][2] + v[2];
 
             if (b->owner->vRotation[0])
             {
               float y2 = (((y - v[1]) * vCos[0]) - ((z - v[2]) * vSin[0])) + v[1];
               float z2 = (((y - v[1]) * vSin[0]) + ((z - v[2]) * vCos[0])) + v[2];
               y = y2;
               z = z2;
             }
             if (b->owner->vRotation[1])
             {
               float z2 = (((z - v[2]) * vCos[1]) - ((x - v[0]) * vSin[1])) + v[2];
               float x2 = (((z - v[2]) * vSin[1]) + ((x - v[0]) * vCos[1])) + v[0];
               x = x2;
               z = z2;
             }
             if (b->owner->vRotation[2])
             {
               float x2 = (((x - v[0]) * vCos[2]) - ((y - v[1]) * vSin[2])) + v[0];
               float y2 = (((x - v[0]) * vSin[2]) + ((y - v[1]) * vCos[2])) + v[1];
               x = x2;
               y = y2;
             }
             qglTexCoord2f (model->pTriList[i].st[j][0], model->pTriList[i].st[j][1]);
             qglVertex3f(x, y, z);
 #endif
             if (g_bDoIt)
             {
               vTest[j][0] = x;
               vTest[j][1] = y;
               vTest[j][2] = model->pTriList[i].v[j][2] + v[2];
               vTest[j][3] = model->pTriList[i].st[j][0];
               vTest[j][4] = model->pTriList[i].st[j][1];
             }
 
           }
           if (g_bDoIt)
           {
             Patch_FromTriangle(vTest[0], vTest[1], vTest[2]);
           }
         }
         qglEnd();
         if (g_PrefsDlg.m_nEntityShowState & ENTITY_WIREFRAME)	// skinned
         {
           qglEnable(GL_CULL_FACE );
           qglEnable(GL_TEXTURE_2D);
 	        qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
         }
         else
         {
 	        qglDisable(GL_TEXTURE_2D);
         }
         model = model->pNext;
       }
 
       if (g_bDoIt)
       {
         g_bDoIt = false;
       }
 
       vec3_t vColor;
       VectorScale(pEclass->color, 0.50, vColor);
 
       vec3_t vCenter, vMin, vMax;
       VectorCopy(b->owner->origin, vCenter);
 
 		  qglColor3fv(vColor);
       qglPointSize(4);
 
       qglBegin(GL_POINTS);
       qglVertex3fv(b->owner->origin);
       qglEnd();
 
       qglBegin(GL_LINES);
       vCenter[0] -= 8;
       qglVertex3fv(vCenter);
       vCenter[0] += 16;
       qglVertex3fv(vCenter);
       vCenter[0] -= 8;
       vCenter[1] -= 8;
       qglVertex3fv(vCenter);
       vCenter[1] += 16;
       qglVertex3fv(vCenter);
       vCenter[1] -= 8;
       vCenter[2] -= 8;
       qglVertex3fv(vCenter);
       vCenter[2] += 16;
       qglVertex3fv(vCenter);
       vCenter[2] -= 8;
       qglEnd();
 
       VectorCopy(vCenter, vMin);
       VectorCopy(vCenter, vMax);
       vMin[0] -= 4;
       vMin[1] -= 4;
       vMin[2] -= 4;
       vMax[0] += 4;
       vMax[1] += 4;
       vMax[2] += 4;
 
 		    qglBegin(GL_LINE_LOOP);
           qglVertex3f(vMin[0],vMin[1],vMin[2]);
           qglVertex3f(vMax[0],vMin[1],vMin[2]);
           qglVertex3f(vMax[0],vMax[1],vMin[2]);
           qglVertex3f(vMin[0],vMax[1],vMin[2]);
 		    qglEnd();
 		    
 		    qglBegin(GL_LINE_LOOP);
 	        qglVertex3f(vMin[0],vMin[1],vMax[2]);
 		      qglVertex3f(vMax[0],vMin[1],vMax[2]);
 		      qglVertex3f(vMax[0],vMax[1],vMax[2]);
 		      qglVertex3f(vMin[0],vMax[1],vMax[2]);
 		    qglEnd();
 
 		    qglBegin(GL_LINES);
   		    qglVertex3f(vMin[0],vMin[1],vMin[2]);
 		      qglVertex3f(vMin[0],vMin[1],vMax[2]);
 		      qglVertex3f(vMin[0],vMax[1],vMax[2]);
 		      qglVertex3f(vMin[0],vMax[1],vMin[2]);
 		      qglVertex3f(vMax[0],vMin[1],vMin[2]);
 		      qglVertex3f(vMax[0],vMin[1],vMax[2]);
 		      qglVertex3f(vMax[0],vMax[1],vMax[2]);
 		      qglVertex3f(vMax[0],vMax[1],vMin[2]);
 		    qglEnd();
 
 
 	    if (g_PrefsDlg.m_nEntityShowState & ENTITY_BOXED)
 	    {
 		    qglColor3fv(pEclass->color);
 
         vec3_t mins, maxs;
         VectorCopy(b->mins, mins);
         VectorCopy(b->maxs, maxs);
 /*
         if (a)
         {
           vec3_t vAngle;
           vAngle[0] = vAngle[1] = 0;
           vAngle[2] = a;
           VectorRotate(mins, vAngle, b->owner->origin, mins);
           VectorRotate(maxs, vAngle, b->owner->origin, maxs);
         }
 */
 		    qglBegin(GL_LINE_LOOP);
           qglVertex3f(mins[0],mins[1],mins[2]);
           qglVertex3f(maxs[0],mins[1],mins[2]);
           qglVertex3f(maxs[0],maxs[1],mins[2]);
           qglVertex3f(mins[0],maxs[1],mins[2]);
 		    qglEnd();
 		    
 		    qglBegin(GL_LINE_LOOP);
 	        qglVertex3f(mins[0],mins[1],maxs[2]);
 		      qglVertex3f(maxs[0],mins[1],maxs[2]);
 		      qglVertex3f(maxs[0],maxs[1],maxs[2]);
 		      qglVertex3f(mins[0],maxs[1],maxs[2]);
 		    qglEnd();
 
 		    qglBegin(GL_LINES);
   		    qglVertex3f(mins[0],mins[1],mins[2]);
 		      qglVertex3f(mins[0],mins[1],maxs[2]);
 		      qglVertex3f(mins[0],maxs[1],maxs[2]);
 		      qglVertex3f(mins[0],maxs[1],mins[2]);
 		      qglVertex3f(maxs[0],mins[1],mins[2]);
 		      qglVertex3f(maxs[0],mins[1],maxs[2]);
 		      qglVertex3f(maxs[0],maxs[1],maxs[2]);
 		      qglVertex3f(maxs[0],maxs[1],mins[2]);
 		    qglEnd();
       }
 	    qglPopAttrib();
       bReturn = true;
     }
     else
     {
       b->bModelFailed = true;
     }
 
   g_bInPaintedModel = false;
   return bReturn;
 }
 /*
 //++timo moved out to mahlib.h
 //++timo remove
 void AngleVectors (vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
 {
 	float		angle;
 	static float		sr, sp, sy, cr, cp, cy;
 	// static to help MS compiler fp bugs
 
 	angle = angles[YAW] * Q_PI / 180;
 	sy = sin(angle);
 	cy = cos(angle);
 	angle = angles[PITCH] * Q_PI / 180;
 	sp = sin(angle);
 	cp = cos(angle);
 	angle = angles[ROLL] * Q_PI / 180;
 	sr = sin(angle);
 	cr = cos(angle);
 
 	if (forward)
 	{
 		forward[0] = cp*cy;
 		forward[1] = cp*sy;
 		forward[2] = -sp;
 	}
 	if (right)
 	{
 		right[0] = (-1*sr*sp*cy+-1*cr*-sy);
 		right[1] = (-1*sr*sp*sy+-1*cr*cy);
 		right[2] = -1*sr*cp;
 	}
 	if (up)
 	{
 		up[0] = (cr*sp*cy+-sr*-sy);
 		up[1] = (cr*sp*sy+-sr*cy);
 		up[2] = cr*cp;
 	}
 }
 */
 void FacingVectors (entity_t *e, vec3_t forward, vec3_t right, vec3_t up)
 {
 	int			angleVal;
 	vec3_t		angles;
 
 	angleVal = IntForKey(e, "angle");
 	if (angleVal == -1)				// up
 	{
 		VectorSet(angles, 270, 0, 0);
 	}
 	else if(angleVal == -2)		// down
 	{
 		VectorSet(angles, 90, 0, 0);
 	}
 	else
 	{
 		VectorSet(angles, 0, angleVal, 0);
 	}
 
 	AngleVectors(angles, forward, right, up);
 }
 
 void Brush_DrawFacingAngle (brush_t *b, entity_t *e)
 {
 	vec3_t	forward, right, up;
 	vec3_t	endpoint, tip1, tip2;
 	vec3_t	start;
 	float	dist;
 
 	VectorAdd(e->brushes.onext->mins, e->brushes.onext->maxs, start);
 	VectorScale(start, 0.5, start);
 	dist = (b->maxs[0] - start[0]) * 2.5;
 
 	FacingVectors (e, forward, right, up);
 	VectorMA (start, dist, forward, endpoint);
 
 	dist = (b->maxs[0] - start[0]) * 0.5;
 	VectorMA (endpoint, -dist, forward, tip1);
 	VectorMA (tip1, -dist, up, tip1);
 	VectorMA (tip1, 2*dist, up, tip2);
 
 	qglColor4f (1, 1, 1, 1);
 	qglLineWidth (4);
 	qglBegin (GL_LINES);
 	qglVertex3fv (start);
 	qglVertex3fv (endpoint);
 	qglVertex3fv (endpoint);
 	qglVertex3fv (tip1);
 	qglVertex3fv (endpoint);
 	qglVertex3fv (tip2);
 	qglEnd ();
 	qglLineWidth (1);
 }
 
 void DrawLight(brush_t *b)
 {
 	vec3_t vTriColor;
 	bool bTriPaint = false;
 
   vTriColor[0] = vTriColor[2] = 1.0;
   vTriColor[1]  = 1.0;
   bTriPaint = true;
   CString strColor = ValueForKey(b->owner, "_color");
   if (strColor.GetLength() > 0)
   {
     float fR, fG, fB;
 	  int n = sscanf(strColor,"%f %f %f", &fR, &fG, &fB);
     if (n == 3)
     {
       vTriColor[0] = fR;
       vTriColor[1] = fG;
       vTriColor[2] = fB;
     }
   }
   qglColor3f(vTriColor[0], vTriColor[1], vTriColor[2]);
 
   vec3_t vCorners[4];
   float fMid = b->mins[2] + (b->maxs[2] - b->mins[2]) / 2;
 
   vCorners[0][0] = b->mins[0];
   vCorners[0][1] = b->mins[1];
   vCorners[0][2] = fMid;
 
   vCorners[1][0] = b->mins[0];
   vCorners[1][1] = b->maxs[1];
   vCorners[1][2] = fMid;
 
   vCorners[2][0] = b->maxs[0];
   vCorners[2][1] = b->maxs[1];
   vCorners[2][2] = fMid;
 
   vCorners[3][0] = b->maxs[0];
   vCorners[3][1] = b->mins[1];
   vCorners[3][2] = fMid;
 
   vec3_t vTop, vBottom;
 
   vTop[0] = b->mins[0] + ((b->maxs[0] - b->mins[0]) / 2);
   vTop[1] = b->mins[1] + ((b->maxs[1] - b->mins[1]) / 2);
   vTop[2] = b->maxs[2];
 
   VectorCopy(vTop, vBottom);
   vBottom[2] = b->mins[2];
 
   vec3_t vSave;
   VectorCopy(vTriColor, vSave);
 
   qglBegin(GL_TRIANGLE_FAN);
   qglVertex3fv(vTop);
   for (int i = 0; i <= 3; i++)
   {
     vTriColor[0] *= 0.95;
     vTriColor[1] *= 0.95;
     vTriColor[2] *= 0.95;
     qglColor3f(vTriColor[0], vTriColor[1], vTriColor[2]);
     qglVertex3fv(vCorners[i]);
   }
   qglVertex3fv(vCorners[0]);
   qglEnd();
   
   VectorCopy(vSave, vTriColor);
   vTriColor[0] *= 0.95;
   vTriColor[1] *= 0.95;
   vTriColor[2] *= 0.95;
 
   qglBegin(GL_TRIANGLE_FAN);
   qglVertex3fv(vBottom);
   qglVertex3fv(vCorners[0]);
   for (i = 3; i >= 0; i--)
   {
     vTriColor[0] *= 0.95;
     vTriColor[1] *= 0.95;
     vTriColor[2] *= 0.95;
     qglColor3f(vTriColor[0], vTriColor[1], vTriColor[2]);
     qglVertex3fv(vCorners[i]);
   }
   qglEnd();
 
   // check for DOOM lights
   CString str = ValueForKey(b->owner, "light_right");
   if (str.GetLength() > 0) {
     vec3_t vRight, vUp, vTarget, vTemp;
     GetVectorForKey (b->owner, "light_right", vRight);
     GetVectorForKey (b->owner, "light_up", vUp);
     GetVectorForKey (b->owner, "light_target", vTarget);
 
     qglColor3f(0, 1, 0);
 		qglBegin(GL_LINE_LOOP);
     VectorAdd(vTarget, b->owner->origin, vTemp);
     VectorAdd(vTemp, vRight, vTemp);
     VectorAdd(vTemp, vUp, vTemp);
     qglVertex3fv(b->owner->origin);
     qglVertex3fv(vTemp);
     VectorAdd(vTarget, b->owner->origin, vTemp);
     VectorAdd(vTemp, vUp, vTemp);
     VectorSubtract(vTemp, vRight, vTemp);
     qglVertex3fv(b->owner->origin);
     qglVertex3fv(vTemp);
     VectorAdd(vTarget, b->owner->origin, vTemp);
     VectorAdd(vTemp, vRight, vTemp);
     VectorSubtract(vTemp, vUp, vTemp);
     qglVertex3fv(b->owner->origin);
     qglVertex3fv(vTemp);
     VectorAdd(vTarget, b->owner->origin, vTemp);
     VectorSubtract(vTemp, vUp, vTemp);
     VectorSubtract(vTemp, vRight, vTemp);
     qglVertex3fv(b->owner->origin);
     qglVertex3fv(vTemp);
     qglEnd();
 
   }
 
 }
 
 void Brush_Draw( brush_t *b )
 {
 	face_t			*face;
 	int				i, order;
 	qtexture_t		*prev = 0;
 	winding_t *w;
 
 	if ( b->owner && ( b->owner->eclass->nShowFlags & ECLASS_PLUGINENTITY ) )
 	{
 		b->owner->pPlugEnt->CamRender();
 		return;
 	}
 	
 	// (TTimo) NOTE: added by build 173, I check after pPlugEnt so it doesn't interfere ?
 	if (b->hiddenBrush)
 	{
 		return;
 	}
 
 	if (b->patchBrush)
 	{
 		//Patch_DrawCam(b->nPatchID);
 		Patch_DrawCam(b->pPatch);
 		//if (!g_bPatchShowBounds)
 		return;
 	}
 	
 	if (b->terrainBrush)
 	{
 		Terrain_DrawCam(b->pTerrain);
 		return;
 	}
 
 	int nDrawMode = g_pParentWnd->GetCamera()->Camera().draw_mode;
 	
 	if (b->owner->eclass->fixedsize)
 	{
 		
 		if (!(g_qeglobals.d_savedinfo.exclude & EXCLUDE_ANGLES) && (b->owner->eclass->nShowFlags & ECLASS_ANGLE))
 		{
 			Brush_DrawFacingAngle(b, b->owner);
 		}
 		
 		if (g_PrefsDlg.m_bNewLightDraw && (b->owner->eclass->nShowFlags & ECLASS_LIGHT))
 		{
 			DrawLight(b);
 			return;
 		}
 		if (nDrawMode == cd_texture || nDrawMode == cd_light)
 			qglDisable (GL_TEXTURE_2D);
 		
 		// if we are wireframing models
 		bool bp = (b->bModelFailed) ? false : PaintedModel(b, true);
 		
 		if (nDrawMode == cd_texture || nDrawMode == cd_light)
 			qglEnable (GL_TEXTURE_2D);
 		
 		if (bp)
 			return;
 	}
 	
 	// guarantee the texture will be set first
 	prev = NULL;
 	for (face = b->brush_faces,order = 0 ; face ; face=face->next, order++)
 	{
 		w = face->face_winding;
 		if (!w)
 		{
 			continue;		// freed face
 		}
 		
 		if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CAULK)
 		{
 			if (strstr(face->texdef.name, "caulk"))
 			{
 				continue;
 			}
 		}
 		
 #if 0
 		if (b->alphaBrush)
 		{
 			if (!(face->texdef.flags & SURF_ALPHA))
 				continue;
 			//--qglPushAttrib(GL_ALL_ATTRIB_BITS);
 			qglDisable(GL_CULL_FACE);
 			//--qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 			//--qglBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 			//--qglDisable(GL_DEPTH_TEST);
 			//--qglBlendFunc (GL_SRC_ALPHA, GL_DST_ALPHA);
 			//--qglEnable (GL_BLEND);
 		}
 #endif
 		
 		if ((nDrawMode == cd_texture || nDrawMode == cd_light) && face->d_texture != prev)
 		{
 			// set the texture for this face
 			prev = face->d_texture;
 			qglBindTexture( GL_TEXTURE_2D, face->d_texture->texture_number );
 		}
 		
 		
 		
 		if (!b->patchBrush)
 		{
 			if (face->texdef.flags & SURF_TRANS33) 
 				qglColor4f ( face->d_color[0], face->d_color[1], face->d_color[2], 0.33 );
 			else if ( face->texdef.flags & SURF_TRANS66) 
 				qglColor4f ( face->d_color[0], face->d_color[1], face->d_color[2], 0.66 );
 			else
 				qglColor3fv( face->d_color );
 		}
 		else
 		{
 			qglColor4f ( face->d_color[0], face->d_color[1], face->d_color[2], 0.13 );
 		}
 		
 		// shader drawing stuff
 		if (face->d_texture->bFromShader)
 		{
 			// setup shader drawing
 			qglColor4f ( face->d_color[0], face->d_color[1], face->d_color[2], face->d_texture->fTrans );
 			
 		}
 		
 		// draw the polygon
 		
 		//if (nDrawMode == cd_light)
 		//{
 		if (g_PrefsDlg.m_bGLLighting)
 		{
 			qglNormal3fv(face->plane.normal);
 		}
 		//}
 		
 		qglBegin(GL_POLYGON);
 		//if (nDrawMode == cd_light)
 		
 		for (i=0 ; i<w->numpoints ; i++)
 		{
 			if (nDrawMode == cd_texture || nDrawMode == cd_light)
 				qglTexCoord2fv( &w->points[i][3] );
 			qglVertex3fv(w->points[i]);
 		}
 		qglEnd();
 	}
 	
 #if 0
 	if (b->alphaBrush)
 	{
 		//--qglPopAttrib();
 		qglEnable(GL_CULL_FACE);
 		//--qglDisable (GL_BLEND);
 		//--qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 	}
 #endif
 	
 	if (b->owner->eclass->fixedsize && (nDrawMode == cd_texture || nDrawMode == cd_light))
 		qglEnable (GL_TEXTURE_2D);
 	
 	qglBindTexture( GL_TEXTURE_2D, 0 );
 }
 
 
 
 void Face_Draw( face_t *f )
 {
 	int i;
 
 	if ( f->face_winding == 0 )
 		return;
 	qglBegin( GL_POLYGON );
 	for ( i = 0 ; i < f->face_winding->numpoints; i++)
 		qglVertex3fv( f->face_winding->points[i] );
 	qglEnd();
 }
 
 void Brush_DrawXY(brush_t *b, int nViewType)
 {
 	face_t *face;
 	int     order;
 	winding_t *w;
 	int        i;
 
 	if (b->hiddenBrush)
 	{
 		return;
 	}
 
 	if (b->patchBrush)
 	{
 		//Patch_DrawXY(b->nPatchID);
 		Patch_DrawXY(b->pPatch);
 		if (!g_bPatchShowBounds)
 			return;
 	}
 
 	if (b->terrainBrush)
 	{
 		Terrain_DrawXY(b->pTerrain, b->owner);
 	}
                      
 
 	if (b->owner->eclass->fixedsize)
 	{
 		if (g_PrefsDlg.m_bNewLightDraw && (b->owner->eclass->nShowFlags & ECLASS_LIGHT))
 		{
 			vec3_t vCorners[4];
 			float fMid = b->mins[2] + (b->maxs[2] - b->mins[2]) / 2;
 
 			vCorners[0][0] = b->mins[0];
 			vCorners[0][1] = b->mins[1];
 			vCorners[0][2] = fMid;
 
 			vCorners[1][0] = b->mins[0];
 			vCorners[1][1] = b->maxs[1];
 			vCorners[1][2] = fMid;
 
 			vCorners[2][0] = b->maxs[0];
 			vCorners[2][1] = b->maxs[1];
 			vCorners[2][2] = fMid;
 
 			vCorners[3][0] = b->maxs[0];
 			vCorners[3][1] = b->mins[1];
 			vCorners[3][2] = fMid;
 
 			vec3_t vTop, vBottom;
 
 			vTop[0] = b->mins[0] + ((b->maxs[0] - b->mins[0]) / 2);
 			vTop[1] = b->mins[1] + ((b->maxs[1] - b->mins[1]) / 2);
 			vTop[2] = b->maxs[2];
 
 			VectorCopy(vTop, vBottom);
 			vBottom[2] = b->mins[2];
 
 			qglPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
 			qglBegin(GL_TRIANGLE_FAN);
 			qglVertex3fv(vTop);
 			qglVertex3fv(vCorners[0]);
 			qglVertex3fv(vCorners[1]);
 			qglVertex3fv(vCorners[2]);
 			qglVertex3fv(vCorners[3]);
 			qglVertex3fv(vCorners[0]);
 			qglEnd();
 			qglBegin(GL_TRIANGLE_FAN);
 			qglVertex3fv(vBottom);
 			qglVertex3fv(vCorners[0]);
 			qglVertex3fv(vCorners[3]);
 			qglVertex3fv(vCorners[2]);
 			qglVertex3fv(vCorners[1]);
 			qglVertex3fv(vCorners[0]);
 			qglEnd();
 			DrawBrushEntityName (b);
 			return;
 		}
 		else if (b->owner->eclass->nShowFlags & ECLASS_MISCMODEL)
 		{
 			if (PaintedModel(b, false))
 			return;
 		}
 	}
 
 	for (face = b->brush_faces,order = 0 ; face ; face=face->next, order++)
 	{
 		// only draw polygons facing in a direction we care about
     if (nViewType == XY)
     {
 		  if (face->plane.normal[2] <= 0)
 			  continue;
     }
     else
     {
       if (nViewType == XZ)
       {
         if (face->plane.normal[1] <= 0)
           continue;
       }
       else 
       {
         if (face->plane.normal[0] <= 0)
           continue;
       }
     }
 
 		w = face->face_winding;
 		if (!w)
 			continue;
 
     //if (b->alphaBrush && !(face->texdef.flags & SURF_ALPHA))
     //  continue;
 
 		// draw the polygon
 		qglBegin(GL_LINE_LOOP);
     for (i=0 ; i<w->numpoints ; i++)
 		  qglVertex3fv(w->points[i]);
 		qglEnd();
 	}
 
 	DrawBrushEntityName (b);
 
 }
 
 /*
 ============
 Brush_Move
 ============
 */
 void Brush_Move (brush_t *b, const vec3_t move, bool bSnap)
 {
   int i;
   face_t *f;
 
   for (f=b->brush_faces ; f ; f=f->next)
   {
     vec3_t vTemp;
     VectorCopy(move, vTemp);
 
     if (g_PrefsDlg.m_bTextureLock)
       Face_MoveTexture(f, vTemp);
     
     for (i=0 ; i<3 ; i++)
       VectorAdd (f->planepts[i], move, f->planepts[i]);
   }
   Brush_Build( b, bSnap );
 
 
   if (b->patchBrush)
   {
     //Patch_Move(b->nPatchID, move);
     Patch_Move(b->pPatch, move);
   }
 
   if (b->terrainBrush)
   {
     Terrain_Move(b->pTerrain, move);
   }
 
 
   // PGM - keep the origin vector up to date on fixed size entities.
   if(b->owner->eclass->fixedsize)
   {
     VectorAdd(b->owner->origin, move, b->owner->origin);
 	  //VectorAdd(b->maxs, b->mins, b->owner->origin);
 	  //VectorScale(b->owner->origin, 0.5, b->owner->origin);
   }
 }
 
 
 
 void Brush_Print(brush_t* b)
 {
   int nFace = 0;
   for (face_t* f = b->brush_faces ; f ; f=f->next)
   {
     Sys_Printf("Face %i\n", nFace++);
     Sys_Printf("%f %f %f\n", f->planepts[0][0], f->planepts[0][1], f->planepts[0][2]);
     Sys_Printf("%f %f %f\n", f->planepts[1][0], f->planepts[1][1], f->planepts[1][2]);
     Sys_Printf("%f %f %f\n", f->planepts[2][0], f->planepts[2][1], f->planepts[2][2]);
   }
  }
 
 
 
 /*
 =============
 Brush_MakeSided
 
 Makes the current brushhave the given number of 2d sides and turns it into a cone
 =============
 */
 void Brush_MakeSidedCone(int sides)
 {
 	int		i;
 	vec3_t	mins, maxs;
 	brush_t	*b;
 	texdef_t	*texdef;
 	face_t	*f;
 	vec3_t	mid;
 	float	width;
 	float	sv, cv;
 
 	if (sides < 3)
 	{
 		Sys_Status ("Bad sides number", 0);
 		return;
 	}
 
 	if (!QE_SingleBrush ())
 	{
 		Sys_Status ("Must have a single brush selected", 0 );
 		return;
 	}
 
 	b = selected_brushes.next;
 	VectorCopy (b->mins, mins);
 	VectorCopy (b->maxs, maxs);
 	texdef = &g_qeglobals.d_texturewin.texdef;
 
 	Brush_Free (b);
 
 	// find center of brush
 	width = 8;
 	for (i=0 ; i<2 ; i++)
 	{
 		mid[i] = (maxs[i] + mins[i])*0.5;
 		if (maxs[i] - mins[i] > width)
 			width = maxs[i] - mins[i];
 	}
 	width /= 2;
 
 	b = Brush_Alloc();
 
 	// create bottom face
 	f = Face_Alloc();
 	f->texdef = *texdef;
 	f->next = b->brush_faces;
 	b->brush_faces = f;
 
 	f->planepts[0][0] = mins[0];f->planepts[0][1] = mins[1];f->planepts[0][2] = mins[2];
 	f->planepts[1][0] = maxs[0];f->planepts[1][1] = mins[1];f->planepts[1][2] = mins[2];
 	f->planepts[2][0] = maxs[0];f->planepts[2][1] = maxs[1];f->planepts[2][2] = mins[2];
 
 	for (i=0 ; i<sides ; i++)
 	{
 		f = Face_Alloc();
 		f->texdef = *texdef;
 		f->next = b->brush_faces;
 		b->brush_faces = f;
 
 		sv = sin (i*3.14159265*2/sides);
 		cv = cos (i*3.14159265*2/sides);
 
 
 		f->planepts[0][0] = floor(mid[0]+width*cv+0.5);
 		f->planepts[0][1] = floor(mid[1]+width*sv+0.5);
 		f->planepts[0][2] = mins[2];
 
 		f->planepts[1][0] = mid[0];
 		f->planepts[1][1] = mid[1];
 		f->planepts[1][2] = maxs[2];
 
 		f->planepts[2][0] = floor(f->planepts[0][0] - width * sv + 0.5);
 		f->planepts[2][1] = floor(f->planepts[0][1] + width * cv + 0.5);
 		f->planepts[2][2] = maxs[2];
 
 	}
 
 	Brush_AddToList (b, &selected_brushes);
 
 	Entity_LinkBrush (world_entity, b);
 
 	Brush_Build( b );
 
 	Sys_UpdateWindows (W_ALL);
 }
 
 /*
 =============
 Brush_MakeSided
 
 Makes the current brushhave the given number of 2d sides and turns it into a sphere
 =============
 
 */
 void Brush_MakeSidedSphere(int sides)
 {
 	int		i,j;
 	vec3_t	mins, maxs;
 	brush_t	*b;
 	texdef_t	*texdef;
 	face_t	*f;
 	vec3_t	mid;
 
 	if (sides < 4)
 	{
 		Sys_Status ("Bad sides number", 0);
 		return;
 	}
 
 	if (!QE_SingleBrush ())
 	{
 		Sys_Status ("Must have a single brush selected", 0 );
 		return;
 	}
 
 	b = selected_brushes.next;
 	VectorCopy (b->mins, mins);
 	VectorCopy (b->maxs, maxs);
 	texdef = &g_qeglobals.d_texturewin.texdef;
 
 	Brush_Free (b);
 
 	// find center of brush
 	float radius = 8;
 	for (i=0 ; i<2 ; i++)
 	{
 		mid[i] = (maxs[i] + mins[i])*0.5;
 		if (maxs[i] - mins[i] > radius)
 			radius = maxs[i] - mins[i];
 	}
 	radius /= 2;
 
 	b = Brush_Alloc();
 
 	float dt = float(2 * Q_PI / sides);
 	float dp = float(Q_PI / sides);
   float t,p;
 	for(i=0; i <= sides-1; i++)
   {
 		for(j=0;j <= sides-2; j++)
 		{
 			t = i * dt;
 			p = float(j * dp - Q_PI / 2);
 
       f = Face_Alloc();
 	    f->texdef = *texdef;
 	    f->next = b->brush_faces;
 	    b->brush_faces = f;
 
       VectorPolar(f->planepts[0], radius, t, p);
       VectorPolar(f->planepts[1], radius, t, p + dp);
       VectorPolar(f->planepts[2], radius, t + dt, p + dp);
 
       for (int k = 0; k < 3; k++)
         VectorAdd(f->planepts[k], mid, f->planepts[k]);
 		}
   }
 
   p = float((sides - 1) * dp - Q_PI / 2);
 	for(i = 0; i <= sides-1; i++)
 	{
 		t = i * dt;
 
     f = Face_Alloc();
 	  f->texdef = *texdef;
 	  f->next = b->brush_faces;
 	  b->brush_faces = f;
 
     VectorPolar(f->planepts[0], radius, t, p);
     VectorPolar(f->planepts[1], radius, t + dt, p + dp);
     VectorPolar(f->planepts[2], radius, t + dt, p);
 
     for (int k = 0; k < 3; k++)
       VectorAdd(f->planepts[k], mid, f->planepts[k]);
 	}
 
 	Brush_AddToList (b, &selected_brushes);
 
 	Entity_LinkBrush (world_entity, b);
 
 	Brush_Build( b );
 
 	Sys_UpdateWindows (W_ALL);
 }
 
 void Face_FitTexture( face_t * face, int nHeight, int nWidth )
 {
   winding_t *w;
   vec3_t   mins,maxs;
   int i;
   float width, height, temp;
   float rot_width, rot_height;
   float cosv,sinv,ang;
   float min_t, min_s, max_t, max_s;
   float s,t;
 	vec3_t	vecs[2];
   vec3_t   coords[4];
 	texdef_t	*td;
 
   if (nHeight < 1)
   {
     nHeight = 1;
   }
   if (nWidth < 1)
   {
     nWidth = 1;
   }
 
   ClearBounds (mins, maxs);
 
 	td = &face->texdef;
 	w = face->face_winding;
 	if (!w)
 	{
     return;
 	}
   for (i=0 ; i<w->numpoints ; i++)
   {
     AddPointToBounds( w->points[i], mins, maxs );
   }
    // 
    // get the current angle
    //
 	ang = td->rotate / 180 * Q_PI;
 	sinv = sin(ang);
 	cosv = cos(ang);
 
 	// get natural texture axis
 	TextureAxisFromPlane(&face->plane, vecs[0], vecs[1]);
 
   min_s = DotProduct( mins, vecs[0] );
   min_t = DotProduct( mins, vecs[1] );
   max_s = DotProduct( maxs, vecs[0] );
   max_t = DotProduct( maxs, vecs[1] );
   width = max_s - min_s;
   height = max_t - min_t;
   coords[0][0] = min_s;
   coords[0][1] = min_t;
   coords[1][0] = max_s;
   coords[1][1] = min_t;
   coords[2][0] = min_s;
   coords[2][1] = max_t;
   coords[3][0] = max_s;
   coords[3][1] = max_t;
   min_s = min_t = 99999;
   max_s = max_t = -99999;
   for (i=0; i<4; i++)
   {
     s = cosv * coords[i][0] - sinv * coords[i][1];
 	  t = sinv * coords[i][0] + cosv * coords[i][1];
     if (i&1)
     {
       if (s > max_s) 
       {
         max_s = s;
       }
     }
     else
     {
       if (s < min_s) 
       {
         min_s = s;
       }
       if (i<2)
       {
         if (t < min_t) 
         {
           min_t = t;
         }
       }
       else
       {
         if (t > max_t) 
         {
           max_t = t;
         }
       }
     }
   }
   rot_width =  (max_s - min_s);
   rot_height = (max_t - min_t);
   td->scale[0] = -(rot_width/((float)(face->d_texture->width*nWidth)));
   td->scale[1] = -(rot_height/((float)(face->d_texture->height*nHeight)));
 
   td->shift[0] = min_s/td->scale[0];
   temp = (int)(td->shift[0] / (face->d_texture->width*nWidth));
   temp = (temp+1)*face->d_texture->width*nWidth;
   td->shift[0] = (int)(temp - td->shift[0])%(face->d_texture->width*nWidth);
 
   td->shift[1] = min_t/td->scale[1];
   temp = (int)(td->shift[1] / (face->d_texture->height*nHeight));
   temp = (temp+1)*(face->d_texture->height*nHeight);
   td->shift[1] = (int)(temp - td->shift[1])%(face->d_texture->height*nHeight);
 }
 
 void Brush_FitTexture( brush_t *b, int nHeight, int nWidth )
 {
 	face_t *face;
 
 	for (face = b->brush_faces ; face ; face=face->next)
   {
     Face_FitTexture( face, nHeight, nWidth );
   }
 }