1HEADmaster

1 files changed, 3467 insertions, 0 deletions

diff --git a/hammer/mapface.cpp b/hammer/mapface.cpp
new file mode 100644
index 0000000..6b89bba
--- /dev/null
+++ b/hammer/mapface.cpp
@@ -0,0 +1,3467 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "stdafx.h"
+#include "collisionutils.h"
+#include "mainfrm.h"
+#include "MapDefs.h"
+#include "MapFace.h"
+#include "MapDisp.h"
+#include "MapWorld.h"
+#include "fgdlib/WCKeyValues.h"
+#include "GlobalFunctions.h"
+#include "Render3D.h"
+#include "Render2D.h"
+#include "SaveInfo.h"
+#include "TextureSystem.h"
+#include "MapDoc.h"
+#include "materialsystem/imesh.h"
+#include "Material.h"
+#include "utlrbtree.h"
+#include "mathlib/vector.h"
+#include "camera.h"
+#include "options.h"
+#include "hammer.h"
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+
+//#define DEBUGPTS
+
+
+#define TEXTURE_AXIS_LENGTH				10			// Rendered texture axis length in world units.
+
+//
+// Components of the texture axes are rounded to integers within this tolerance. This tolerance corresponds
+// to an angle of about 0.06 degrees.
+//
+#define TEXTURE_AXIS_ROUND_EPSILON		0.001		
+
+
+//
+// For passing into LoadKeyCallback. Collects key value data while loading.
+//
+struct LoadFace_t
+{
+	CMapFace *pFace;
+	char szTexName[MAX_PATH];
+};
+
+
+BOOL CheckFace(Vector *Points, int nPoints, Vector *normal, float dist, CCheckFaceInfo *pInfo);
+LPCTSTR GetDefaultTextureName();
+
+
+#pragma warning(disable:4244)
+
+
+//
+// Static member data initialization.
+//
+bool CMapFace::m_bShowFaceSelection = true;
+IEditorTexture *CMapFace::m_pLightmapGrid = NULL;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor. Initializes data members and sets the texture to the
+//			default texture.
+//-----------------------------------------------------------------------------
+CMapFace::CMapFace(void)
+{
+	memset(&texture, 0, sizeof(texture));
+	memset(&plane, 0, sizeof(plane));
+
+	m_pTexture = NULL;
+	m_pTangentAxes = NULL;
+    m_DispHandle = EDITDISPHANDLE_INVALID;
+
+	Points = NULL;
+	nPoints = 0;
+	m_nFaceID = 0;
+	m_pTextureCoords = NULL;
+	m_pLightmapCoords = NULL;
+	m_uchAlpha = 255;
+
+	m_pDetailObjects = NULL;
+
+	texture.nLightmapScale = g_pGameConfig->GetDefaultLightmapScale();
+
+	texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
+	texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
+
+	SetTexture(GetNullTextureName());
+	
+	if (m_pLightmapGrid == NULL)
+	{
+		m_pLightmapGrid = g_Textures.FindActiveTexture("Debug/debugluxelsnoalpha");
+	}
+
+	m_bIgnoreLighting = false;
+	m_fSmoothingGroups = SMOOTHING_GROUP_DEFAULT;
+	UpdateFaceFlags();
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor. Frees points and texture coordinates.
+//-----------------------------------------------------------------------------
+CMapFace::~CMapFace(void)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	delete [] Points;
+	Points = NULL;
+
+	delete [] m_pTextureCoords;
+	m_pTextureCoords = NULL;
+
+	delete [] m_pLightmapCoords;
+	m_pLightmapCoords = NULL;
+
+	delete m_pDetailObjects;
+	m_pDetailObjects = NULL;
+
+	FreeTangentSpaceAxes();
+
+	if( HasDisp() )
+	{
+		IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+
+		if( pDispMgr )
+		{
+			pDispMgr->RemoveFromWorld( GetDisp() );
+		}
+
+		// destroy handle
+		SetDisp( EDITDISPHANDLE_INVALID );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempts to fix this face. This is called by the check for problems
+//			code when a face is reported as invalid.
+// Output : Returns TRUE on success, FALSE on failure.
+//-----------------------------------------------------------------------------
+BOOL CMapFace::Fix(void)
+{
+	CalcPlane();
+	CalcTextureCoords();
+
+	// Create any detail objects if appropriate
+	DetailObjects::BuildAnyDetailObjects(this);
+
+	return(CheckFace());
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the short texture name in 'pszName'. Places an empty string
+//			in 'pszName' if the face has no texture.
+//-----------------------------------------------------------------------------
+void CMapFace::GetTextureName(char *pszName) const
+{
+	Assert(pszName != NULL);
+
+	if (pszName != NULL)
+	{
+		if (m_pTexture != NULL)
+		{
+			m_pTexture->GetShortName(pszName);
+		}
+		else
+		{
+			pszName[0] = '\0';
+		}
+	}
+}
+
+static char *InvisToolTextures[]={
+	"occluder",
+	"areaportal",
+	"invisible",
+	"skip",
+	"trigger",
+	"hint",
+	"fog",
+	"origin",
+	"toolsnodraw",
+};
+
+void CMapFace::UpdateFaceFlags( void )
+{
+	char tname[2048];
+	GetTextureName( tname );
+	m_nFaceFlags = 0;
+	if (strstr(tname,"tools"))
+	{
+		if ( strstr( tname, "blocklight" ) )
+		{
+			m_nFaceFlags |= FACE_FLAGS_NODRAW_IN_LPREVIEW;
+		}					 
+		if ( strstr( tname, "skybox") )
+		{
+			m_nFaceFlags |= FACE_FLAGS_NOSHADOW;
+		}					 
+		for(int i=0;i<NELEMS(InvisToolTextures); i++)
+			if (strstr( tname, InvisToolTextures[i] ) )
+			{
+				m_nFaceFlags |= FACE_FLAGS_NODRAW_IN_LPREVIEW | FACE_FLAGS_NOSHADOW;
+				break;
+			}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Populates this face with another face's information.
+// Input  : pFrom - The face to copy.
+// Output : CMapFace
+//-----------------------------------------------------------------------------
+CMapFace *CMapFace::CopyFrom(const CMapFace *pObject, DWORD dwFlags, bool bUpdateDependencies)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	const CMapFace *pFrom = dynamic_cast<const CMapFace *>(pObject);
+	Assert(pFrom != NULL);
+
+	if (pFrom != NULL)
+	{
+		//
+		// Free our points first.
+		//
+		if (Points != NULL)
+		{
+			delete [] Points;
+			Points = NULL;
+		}
+
+		if (m_pTextureCoords != NULL)
+		{
+			delete [] m_pTextureCoords;
+			m_pTextureCoords = NULL;
+		}
+
+		if (m_pLightmapCoords != NULL)
+		{
+			delete [] m_pLightmapCoords;
+			m_pLightmapCoords = NULL;
+		}
+
+		FreeTangentSpaceAxes();
+
+		nPoints = 0;
+
+		//
+		// Copy the member data.
+		//
+		m_nFaceID = pFrom->m_nFaceID;
+		m_eSelectionState = pFrom->GetSelectionState();
+		texture = pFrom->texture;
+		m_pTexture = pFrom->m_pTexture;
+		m_bIsCordonFace = pFrom->m_bIsCordonFace;
+
+		//
+		// Allocate points memory.
+		//
+		if (dwFlags & COPY_FACE_POINTS)
+		{
+			Points = NULL;
+			nPoints = pFrom->nPoints;
+
+			if (pFrom->Points && nPoints)
+			{
+				AllocatePoints(nPoints);
+				AllocTangentSpaceAxes( nPoints );
+				memcpy(Points, pFrom->Points, sizeof(Vector) * nPoints);
+				memcpy(m_pTextureCoords, pFrom->m_pTextureCoords, sizeof(Vector2D) * nPoints);
+				memcpy(m_pLightmapCoords, pFrom->m_pLightmapCoords, sizeof(Vector2D) * nPoints);
+				memcpy(m_pTangentAxes, pFrom->m_pTangentAxes, sizeof(TangentSpaceAxes_t) * nPoints);
+			}
+		}
+		else
+		{
+			Points = NULL;
+			m_pTextureCoords = 0;
+			m_pLightmapCoords = 0;
+			m_pTangentAxes = 0;
+			nPoints = 0;
+		}
+
+		//
+		// Copy the plane. You shouldn't copy the points without copying the plane,
+		// so we do it if either bit is set.
+		//
+		if ((dwFlags & COPY_FACE_POINTS) || (dwFlags & COPY_FACE_PLANE))
+		{
+			plane = pFrom->plane;
+		}
+		else
+		{
+			memset(&plane, 0, sizeof(plane));
+		}
+
+        //
+        // copy the displacement info.
+		//
+		// If we do have displacement, then we'll never be asked to become a copy of
+		// a face that does not have a displacement, because you cannot undo a Generate
+		// Displacement operation.
+        //
+        if( pFrom->HasDisp() )
+        {
+			//
+			// Allocate a new displacement info if we don't already have one.
+			//
+			if( !HasDisp() )
+			{
+				SetDisp( EditDispMgr()->Create() );
+			}
+
+			CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+			pDisp->SetParent( this );
+
+			CMapDisp *pFromDisp = EditDispMgr()->GetDisp( pFrom->m_DispHandle );
+			pDisp->CopyFrom( pFromDisp, bUpdateDependencies );
+        }
+		else
+		{
+			SetDisp( EDITDISPHANDLE_INVALID );
+		}
+	
+		// Copy CMapAtom fields. dvs: this should be done in CMapAtom::CopyFrom!
+		r = pFrom->r;
+		g = pFrom->g;
+		b = pFrom->b;
+
+		m_uchAlpha = pFrom->m_uchAlpha;
+		m_bIgnoreLighting = pFrom->m_bIgnoreLighting;
+
+		// Copy the smoothing group data.
+		m_fSmoothingGroups = pFrom->m_fSmoothingGroups;
+
+		// Delete any existing and build any new detail objects
+		delete m_pDetailObjects;
+		m_pDetailObjects = NULL;
+		DetailObjects::BuildAnyDetailObjects(this);
+	}
+	UpdateFaceFlags();
+	return(this);
+}
+
+
+//-----------------------------------------------------------------------------
+// Called any time this object is modified due to an Undo or Redo.
+//-----------------------------------------------------------------------------
+void CMapFace::OnUndoRedo()
+{
+	// It's not valid to have selected faces outside of face edit mode.
+	// If the user modified this face, then closed the texture application
+	// dialog, then did an Undo, clear our selection state.
+	if ( !GetMainWnd()->IsInFaceEditMode() )
+	{
+		m_eSelectionState = SELECT_NONE;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a face from a list of points.
+// Input  : pPoints - An array of points.
+//			_nPoints - Number of points. If nPoints < 0, reverse points.
+//-----------------------------------------------------------------------------
+void CMapFace::CreateFace(Vector *pPoints, int _nPoints, bool bIsCordonFace)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	if (_nPoints > 0)
+	{
+		AllocatePoints(_nPoints);
+		Assert(nPoints > 0);
+		if (nPoints > 0)
+		{
+			memcpy(Points, pPoints, nPoints * sizeof(Vector));
+		}
+	}
+	else
+	{
+		AllocatePoints(-_nPoints);
+		Assert(nPoints > 0);
+		if (nPoints > 0)
+		{
+			int j = 0;
+			for (int i = nPoints - 1; i >= 0; i--)
+			{
+				Points[j++] = pPoints[i];
+			}
+		}
+	}
+
+	SetCordonFace( bIsCordonFace );
+
+#ifdef DEBUGPTS
+	DebugPoints();
+#endif
+
+	CalcPlaneFromFacePoints();
+	CalcTextureCoords();
+
+	// Create any detail objects if appropriate
+	DetailObjects::BuildAnyDetailObjects(this);
+
+#if 0
+    //
+    // create the displacement map -- if need be
+    //
+    if( m_pMapDisp )
+    {
+		m_pMapDisp->InitSurfData( this, false );
+        m_pMapDisp->Create();
+    }
+#endif
+}
+
+
+Vector FaceNormals[6] =
+{
+	Vector(0, 0, 1),		// floor
+	Vector(0, 0, -1),		// ceiling
+	Vector(0, -1, 0),		// north wall
+	Vector(0, 1, 0),		// south wall
+	Vector(-1, 0, 0),		// east wall
+	Vector(1, 0, 0),		// west wall
+};
+
+
+Vector DownVectors[6] =
+{
+	Vector(0, -1, 0),		// floor
+	Vector(0, -1, 0),		// ceiling
+	Vector(0, 0, -1),		// north wall
+	Vector(0, 0, -1),		// south wall
+	Vector(0, 0, -1),		// east wall
+	Vector(0, 0, -1),		// west wall
+};
+
+
+Vector RightVectors[6] =
+{
+	Vector(1, 0, 0),		// floor
+	Vector(1, 0, 0),		// ceiling
+	Vector(1, 0, 0),		// north wall
+	Vector(1, 0, 0),		// south wall
+	Vector(0, 1, 0),		// east wall
+	Vector(0, 1, 0),		// west wall
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : index - 
+//			downVect - 
+//-----------------------------------------------------------------------------
+void CMapFace::GetDownVector( int index, Vector& downVect )
+{
+    downVect = DownVectors[index];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : Center - 
+//-----------------------------------------------------------------------------
+void CMapFace::GetCenter(Vector& Center)
+{
+	Assert(nPoints > 0);
+
+	Center.Init();
+
+	if (nPoints != 0)
+	{
+		for (int i = 0; i < nPoints; i++)
+		{
+			Center[0] += Points[i][0];
+			Center[1] += Points[i][1];
+			Center[2] += Points[i][2];
+		}
+
+		Center[0] /= nPoints;
+		Center[1] /= nPoints;
+		Center[2] /= nPoints;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines the general orientation of a face based on its normal vector.
+// Output : FaceOrientation_t
+//-----------------------------------------------------------------------------
+FaceOrientation_t CMapFace::GetOrientation(void) const
+{
+	// The normal must have a nonzero length!
+	if ((plane.normal[0] == 0) && (plane.normal[1] == 0) && (plane.normal[2] == 0))
+	{
+		return(FACE_ORIENTATION_INVALID);
+	}
+
+	//
+	// Find the axis that the surface normal has the greatest projection onto.
+	//
+	float fDot;
+	float fMaxDot;
+	Vector Normal;
+
+	FaceOrientation_t eOrientation = FACE_ORIENTATION_INVALID;
+
+	Normal = plane.normal;
+	VectorNormalize(Normal);
+
+	fMaxDot = 0;
+	for (int i = 0; i < 6; i++)
+	{
+		fDot = DotProduct(Normal, FaceNormals[i]);
+
+		if (fDot >= fMaxDot)
+		{
+			fMaxDot = fDot;
+			eOrientation = (FaceOrientation_t)i;
+		}
+	}
+
+	return(eOrientation);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : eAlignment - 
+//			dwFlags - 
+//-----------------------------------------------------------------------------
+void CMapFace::InitializeTextureAxes(TextureAlignment_t eAlignment, DWORD dwFlags)
+{
+	FaceOrientation_t eOrientation;
+
+	//
+	// If the texture axis information has been initialized, don't reinitialize unless
+	// the FORCE flag is set.
+	//
+	if ((!(dwFlags & INIT_TEXTURE_FORCE)) && 
+		((texture.UAxis[0] != 0) || (texture.UAxis[1] != 0) || (texture.UAxis[2] != 0) ||
+		 (texture.VAxis[0] != 0) || (texture.VAxis[1] != 0) || (texture.VAxis[2] != 0)))
+	{
+		return;
+	}
+
+	if (dwFlags & INIT_TEXTURE_ROTATION)
+	{
+		texture.rotate = 0;
+	}
+
+	if (dwFlags & INIT_TEXTURE_SHIFT)
+	{
+		texture.UAxis[3] = 0;
+		texture.VAxis[3] = 0;
+	}
+
+	if (dwFlags & INIT_TEXTURE_SCALE)
+	{
+		texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
+		texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
+	}
+
+	if (dwFlags & INIT_TEXTURE_AXES)
+	{
+		// don't reset the shift component [3]
+		texture.UAxis.AsVector3D().Init();
+		texture.VAxis.AsVector3D().Init();
+
+		// Determine the general orientation of this face (floor, ceiling, n wall, etc.)
+		eOrientation = GetOrientation();
+		if (eOrientation == FACE_ORIENTATION_INVALID)
+		{
+			CalcTextureCoords();
+			return;
+		}
+
+		// Pick a world axis aligned V axis based on the face orientation.
+		texture.VAxis.AsVector3D() = DownVectors[eOrientation];
+
+		//
+		// If we are using face aligned textures, calculate the texture axes.
+		//
+		if (eAlignment == TEXTURE_ALIGN_FACE)
+		{
+			// Using that axis-aligned V axis, calculate the true U axis
+			CrossProduct(plane.normal, texture.VAxis.AsVector3D(), texture.UAxis.AsVector3D());
+			VectorNormalize(texture.UAxis.AsVector3D());
+
+			// Now use the true U axis to calculate the true V axis.
+			CrossProduct(texture.UAxis.AsVector3D(), plane.normal, texture.VAxis.AsVector3D());
+			VectorNormalize(texture.VAxis.AsVector3D());
+		}
+		//
+		// If we are using world (or "natural") aligned textures, use the V axis as is
+		// and pick the corresponding U axis from the table.
+		//
+		else if (eAlignment == TEXTURE_ALIGN_WORLD)
+		{
+			texture.UAxis.AsVector3D() = RightVectors[eOrientation];
+		}
+		//
+		// Quake-style texture alignment used a different axis convention.
+		//
+		else
+		{
+			InitializeQuakeStyleTextureAxes(texture.UAxis, texture.VAxis);
+		}
+	
+		if (texture.rotate != 0)
+		{
+			RotateTextureAxes(texture.rotate);
+		}
+	}
+
+	CalcTextureCoords();
+
+	// Create any detail objects if appropriate
+	DetailObjects::BuildAnyDetailObjects(this);
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks for a texture axis perpendicular to the face.
+// Output : Returns TRUE on success, FALSE on failure.
+//-----------------------------------------------------------------------------
+BOOL CMapFace::IsTextureAxisValid(void) const
+{
+	//
+	// Generate the texture normal axis, which may be different from the
+	// face normal, depending on texture alignment.
+	//
+	Vector TexNormalAxis;
+	CrossProduct(texture.VAxis.AsVector3D(), texture.UAxis.AsVector3D(), TexNormalAxis);
+	return(DotProduct(plane.normal, TexNormalAxis) != 0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Normalize the U/V shift values to be less than the texture width/height.
+//-----------------------------------------------------------------------------
+void CMapFace::NormalizeTextureShifts(void)
+{
+	//
+	// HACK: this should really be elsewhere, but it can live here for now.
+	// Round all components of our texture axes within an epsilon.
+	//
+	for (int nDim = 0; nDim < 4; nDim++)
+	{
+		int nValue = V_rint(texture.UAxis[nDim]);
+		if (fabs(texture.UAxis[nDim] - nValue) < TEXTURE_AXIS_ROUND_EPSILON)
+		{
+			texture.UAxis[nDim] = nValue;
+		}
+
+		nValue = V_rint(texture.VAxis[nDim]);
+		if (fabs(texture.VAxis[nDim] - nValue) < TEXTURE_AXIS_ROUND_EPSILON)
+		{
+			texture.VAxis[nDim] = nValue;
+		}
+	}
+
+	if (m_pTexture == NULL)
+	{
+		return;
+	}
+
+	if (m_pTexture->GetWidth() != 0)
+	{
+		texture.UAxis[3] = fmod(texture.UAxis[3], m_pTexture->GetWidth());
+	}
+
+	if (m_pTexture->GetHeight() != 0)
+	{
+		texture.VAxis[3] = fmod(texture.VAxis[3], m_pTexture->GetHeight());
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines the bounding box of a face in world space.
+// Input  : pfMins - Receives the face X, Y, Z minima.
+//			pfMaxs - Receives the face X, Y, Z maxima.
+//-----------------------------------------------------------------------------
+void CMapFace::GetFaceBounds(Vector& pfMins, Vector& pfMaxs) const
+{
+	for (int nPoint = 0; nPoint < nPoints; nPoint++)
+	{
+		if ((Points[nPoint][0] < pfMins[0]) || (nPoint == 0))
+		{
+			pfMins[0] = Points[nPoint][0];
+		}
+
+		if ((Points[nPoint][1] < pfMins[1]) || (nPoint == 0))
+		{
+			pfMins[1] = Points[nPoint][1];
+		}
+
+		if ((Points[nPoint][2] < pfMins[2]) || (nPoint == 0))
+		{
+			pfMins[2] = Points[nPoint][2];
+		}
+
+		if ((Points[nPoint][0] > pfMaxs[0]) || (nPoint == 0))
+		{
+			pfMaxs[0] = Points[nPoint][0];
+		}
+
+		if ((Points[nPoint][1] > pfMaxs[1]) || (nPoint == 0))
+		{
+			pfMaxs[1] = Points[nPoint][1];
+		}
+
+		if ((Points[nPoint][2] > pfMaxs[2]) || (nPoint == 0))
+		{
+			pfMaxs[2] = Points[nPoint][2];
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds the top left and bottom right points on the face in texture space.
+//			These points are returned in texture space, not world space.
+// Input  : TopLeft - 
+//			BottomRight - 
+//-----------------------------------------------------------------------------
+void CMapFace::GetFaceTextureExtents(Vector2D & TopLeft, Vector2D & BottomRight) const
+{
+	BOOL bFirst = TRUE;
+
+	for (int nPoint = 0; nPoint < nPoints; nPoint++)
+	{
+		Vector2D Test;
+
+		Test[0] = DotProduct(Points[nPoint], texture.UAxis.AsVector3D()) / texture.scale[0];
+		Test[1] = DotProduct(Points[nPoint], texture.VAxis.AsVector3D()) / texture.scale[1];
+
+		if ((Test[0] < TopLeft[0]) || (bFirst))
+		{
+			TopLeft[0] = Test[0];
+		}
+
+		if ((Test[1] < TopLeft[1]) || (bFirst))
+		{
+			TopLeft[1] = Test[1];
+		}
+
+		if ((Test[0] > BottomRight[0]) || (bFirst))
+		{
+			BottomRight[0] = Test[0];
+		}
+
+		if ((Test[1] > BottomRight[1]) || (bFirst))
+		{
+			BottomRight[1] = Test[1];
+		}
+
+		bFirst = FALSE;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the distance along the face normal of a given point. The
+//			distance will be negative if the point is behind the face, positive
+//			if the point is in front of the face.
+// Input  : fPoint - Point to calculate normal distance.
+//-----------------------------------------------------------------------------
+float CMapFace::GetNormalDistance(Vector& fPoint)
+{
+	float fDot = DotProduct(fPoint, plane.normal);
+	return(fDot - plane.dist);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines the texture alignment(s) of this face. The alignments are
+//			are returned as TextureAlignment_t values OR'ed together.
+//
+// Output : Returns an integer with any of the following flags set:
+//
+//			TEXTURE_ALIGN_FACE - the texture axes are face aligned.
+//			TEXTURE_ALIGN_WORLD - the texture axes are world aligned.
+//
+//			If the returned value is zero (TEXTURE_ALIGN_NONE), the texture axes
+//			are neither face aligned nor world aligned.
+//-----------------------------------------------------------------------------
+int CMapFace::GetTextureAlignment(void) const
+{
+	Vector TexNormalAxis;
+	int nAlignment = TEXTURE_ALIGN_NONE;
+
+	//
+	// Generate the texture normal axis, which may be different from the
+	// face normal, depending on texture alignment.
+	//
+	CrossProduct(texture.VAxis.AsVector3D(), texture.UAxis.AsVector3D(), TexNormalAxis);
+	VectorNormalize(TexNormalAxis);
+
+	//
+	// Check for face alignment.
+	//
+	if (DotProduct(TexNormalAxis, plane.normal) > 0.9999)
+	{
+		nAlignment |= TEXTURE_ALIGN_FACE;
+	}
+
+	//
+	// Check for world alignment.
+	//
+	FaceOrientation_t eOrientation = GetOrientation();
+	if (eOrientation != FACE_ORIENTATION_INVALID)
+	{
+		Vector WorldTexNormal;
+
+		CrossProduct(DownVectors[eOrientation], RightVectors[eOrientation], WorldTexNormal);
+		if (DotProduct(TexNormalAxis, WorldTexNormal) > 0.9999)
+		{
+			nAlignment |= TEXTURE_ALIGN_WORLD;
+		}
+	}
+
+	return(nAlignment);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds the top left and bottom right points of the given world extents
+//			in texture space. These points are returned in texture space, not world space,
+//			so a simple rectangle will suffice.
+// Input  : Extents - 
+//			TopLeft - 
+//			BottomRight - 
+//-----------------------------------------------------------------------------
+void CMapFace::GetTextureExtents(Extents_t Extents, Vector2D & TopLeft, Vector2D & BottomRight) const
+{
+	BOOL bFirst = TRUE;
+
+	for (int nPoint = 0; nPoint < NUM_EXTENTS_DIMS; nPoint++)
+	{
+		Vector2D Test;
+
+		Test[0] = DotProduct(Extents[nPoint], texture.UAxis.AsVector3D()) / texture.scale[0];
+		Test[1] = DotProduct(Extents[nPoint], texture.VAxis.AsVector3D()) / texture.scale[1];
+
+		if ((Test[0] < TopLeft[0]) || (bFirst))
+		{
+			TopLeft[0] = Test[0];
+		}
+
+		if ((Test[1] < TopLeft[1]) || (bFirst))
+		{
+			TopLeft[1] = Test[1];
+		}
+
+		if ((Test[0] > BottomRight[0]) || (bFirst))
+		{
+			BottomRight[0] = Test[0];
+		}
+
+		if ((Test[1] > BottomRight[1]) || (bFirst))
+		{
+			BottomRight[1] = Test[1];
+		}
+
+		bFirst = FALSE;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines the world extents of the face. Different from a bounding
+//			box in that each point in the returned extents is actually on the face.
+// Input  : Extents - 
+//-----------------------------------------------------------------------------
+void CMapFace::GetFaceExtents(Extents_t Extents) const
+{
+	BOOL bFirst = TRUE;
+
+	for (int nPoint = 0; nPoint < nPoints; nPoint++)
+	{
+		if ((Points[nPoint][0] < Extents[EXTENTS_XMIN][0]) || (bFirst))
+		{
+			Extents[EXTENTS_XMIN] = Points[nPoint];
+		}
+
+		if ((Points[nPoint][0] > Extents[EXTENTS_XMAX][0]) || (bFirst))
+		{
+			Extents[EXTENTS_XMAX] = Points[nPoint];
+		}
+
+		if ((Points[nPoint][1] < Extents[EXTENTS_YMIN][1]) || (bFirst))
+		{
+			Extents[EXTENTS_YMIN] = Points[nPoint];
+		}
+
+		if ((Points[nPoint][1] > Extents[EXTENTS_YMAX][1]) || (bFirst))
+		{
+			Extents[EXTENTS_YMAX] = Points[nPoint];
+		}
+
+		if ((Points[nPoint][2] < Extents[EXTENTS_ZMIN][2]) || (bFirst))
+		{
+			Extents[EXTENTS_ZMIN] = Points[nPoint];
+		}
+
+		if ((Points[nPoint][2] > Extents[EXTENTS_ZMAX][2]) || (bFirst))
+		{
+			Extents[EXTENTS_ZMAX] = Points[nPoint];
+		}
+
+		bFirst = FALSE;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : eJustification - 
+//			Extents - 
+//-----------------------------------------------------------------------------
+void CMapFace::JustifyTextureUsingExtents(TextureJustification_t eJustification, Extents_t Extents)
+{
+	Vector2D Center;
+
+	if (!texture.scale[0])
+	{
+		texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
+	}
+
+	if (!texture.scale[1])
+	{
+		texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
+	}
+
+	// Skip all the mucking about for a justification of NONE.
+	if (eJustification == TEXTURE_JUSTIFY_NONE)
+	{
+		texture.UAxis[3] = 0;
+		texture.VAxis[3] = 0;
+		CalcTextureCoords();
+		return;
+	}
+
+	// For fit justification, use a scale of 1 for initial calculations.
+	if (eJustification == TEXTURE_JUSTIFY_FIT)
+	{
+		texture.scale[0] = 1.0;
+		texture.scale[1] = 1.0;
+	}
+
+	Vector2D TopLeft;
+	Vector2D BottomRight;
+
+	GetTextureExtents(Extents, TopLeft, BottomRight);
+
+	// Find the face center in U/V space.
+	Center[0] = (TopLeft[0] + BottomRight[0]) / 2;
+	Center[1] = (TopLeft[1] + BottomRight[1]) / 2;
+
+	//
+	// Perform the justification.
+	//
+	switch (eJustification)
+	{
+		// Align the top left corner of the texture with the top left corner of the face.
+		case TEXTURE_JUSTIFY_TOP:
+		{
+			texture.VAxis[3] = -TopLeft[1];
+			break;
+		}
+
+		// Align the top left corner of the texture with the top left corner of the face.
+		case TEXTURE_JUSTIFY_BOTTOM:
+		{
+			texture.VAxis[3] = -BottomRight[1] + m_pTexture->GetHeight();
+			break;
+		}
+
+		// Align the left side of the texture with the left side of the face.
+		case TEXTURE_JUSTIFY_LEFT:
+		{
+			texture.UAxis[3] = -TopLeft[0];
+			break;
+		}
+
+		// Align the right side of the texture with the right side of the face.
+		case TEXTURE_JUSTIFY_RIGHT:
+		{
+			texture.UAxis[3] = -BottomRight[0] + m_pTexture->GetWidth();
+			break;
+		}
+
+		// Center the texture on the face.
+		case TEXTURE_JUSTIFY_CENTER:
+		{
+			texture.UAxis[3] = -Center[0] + (m_pTexture->GetWidth() / 2);
+			texture.VAxis[3] = -Center[1] + (m_pTexture->GetHeight() / 2);
+			break;
+		}
+
+		// Scale the texture to exactly fit the face.
+		case TEXTURE_JUSTIFY_FIT:
+		{
+			// Calculate the appropriate scale.
+			if (m_pTexture && m_pTexture->GetWidth() && m_pTexture->GetHeight())
+			{
+				texture.scale[0] = (BottomRight[0] - TopLeft[0]) / m_pTexture->GetWidth();
+				texture.scale[1] = (BottomRight[1] - TopLeft[1]) / m_pTexture->GetHeight();
+			}
+			else
+			{
+				texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
+				texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
+			}
+
+			// Justify top left.
+			JustifyTextureUsingExtents(TEXTURE_JUSTIFY_TOP, Extents);
+			JustifyTextureUsingExtents(TEXTURE_JUSTIFY_LEFT, Extents);
+
+			break;
+		}
+	}
+
+	NormalizeTextureShifts();
+	CalcTextureCoords();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : eJustification - 
+//-----------------------------------------------------------------------------
+void CMapFace::JustifyTexture(TextureJustification_t eJustification)
+{
+	Extents_t Extents;
+	GetFaceExtents(Extents);
+	JustifyTextureUsingExtents(eJustification, Extents);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Offsets a texture due to texture locking when moving a face.
+// Input  : Delta - The x, y, z translation that was applied to the face points.
+//-----------------------------------------------------------------------------
+void CMapFace::OffsetTexture(const Vector &Delta)
+{
+	//
+	// Find the projection in U/V space of this movement
+	// and shift the textures by that.
+	//
+	texture.UAxis[3] -= DotProduct(Delta, texture.UAxis.AsVector3D()) / texture.scale[0];
+	texture.VAxis[3] -= DotProduct(Delta, texture.VAxis.AsVector3D()) / texture.scale[1];
+
+	NormalizeTextureShifts();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Rotates the texture axes fDegrees counterclockwise around the
+//			texture normal axis.
+// Input  : fDegrees - Degrees to rotate the texture axes.
+//-----------------------------------------------------------------------------
+void CMapFace::RotateTextureAxes(float fDegrees)
+{
+	VMatrix Matrix;
+	Vector TexNormalAxis;
+	Vector4D UAxis;
+	Vector4D VAxis;
+	
+	// Generate the texture normal axis, which may be different from the
+	// face normal, depending on texture alignment.
+	CrossProduct(texture.VAxis.AsVector3D(), texture.UAxis.AsVector3D(), TexNormalAxis);
+
+	// Rotate the texture axes around the texture normal.
+	AxisAngleMatrix(Matrix, TexNormalAxis, fDegrees);
+
+	Matrix.V4Mul( texture.UAxis, UAxis );
+	Matrix.V4Mul( texture.VAxis, VAxis );
+
+	texture.UAxis = UAxis;
+	texture.VAxis = VAxis;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Rebuilds the plane normal and distance from the plane points.
+//-----------------------------------------------------------------------------
+void CMapFace::CalcPlane(void)
+{
+	//
+	// Build the plane normal and distance from the three plane points.
+	//
+	plane.normal = GetNormalFromPoints( plane.planepts[0], plane.planepts[1], plane.planepts[2] );
+	plane.dist = DotProduct(plane.planepts[0], plane.normal);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Rebuilds the plane points from our face points.
+//-----------------------------------------------------------------------------
+void CMapFace::CalcPlaneFromFacePoints(void)
+{
+	if ((nPoints >= 3) && (Points != NULL))
+	{
+		//
+		// Use the face points as a preliminary set of plane points.
+		//
+		memcpy(plane.planepts, Points, sizeof(Vector) * 3);
+
+		//
+		// Generate the plane normal and distance from the plane points.
+		//
+		CalcPlane();
+
+		//
+		// Now project large coordinates onto the plane to generate new
+		// plane points that will be less prone to error creep.
+		//
+		// UNDONE: push out the points along the plane for better precision
+	}
+}
+
+
+void CMapFace::AddShadowingTriangles( CUtlVector<Vector> &tri_list )
+{
+	// create a fan
+	if (! (m_nFaceFlags & FACE_FLAGS_NOSHADOW ))
+		for(int i=2;i<nPoints;i++)
+		{
+			tri_list.AddToTail( Points[0] );
+			tri_list.AddToTail( Points[i-1] );
+			tri_list.AddToTail( Points[i] );
+		}
+}
+
+#ifdef DEBUGPTS
+void CMapFace::DebugPoints(void)
+{
+	// check for dup points
+	for(i = 0; i < nPoints; i++)
+	{
+		for(int j = 0; j < nPoints; j++)
+		{
+			if(j == i)
+				continue;
+			if(Points[j][0] == Points[i][0] &&
+				Points[j][1] == Points[i][1] &&
+				Points[j][2] == Points[i][2])
+			{
+				AfxMessageBox("Dup Points in CMapFace::Create(winding_t*)");
+				break;
+			}
+		}
+	}
+}
+#endif
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Create the face from a winding type.
+//	w - Winding from which to create the face.
+//	nFlags - 
+//		CREATE_FACE_PRESERVE_PLANE:
+//		CREATE_FACE_CLIPPING: the new face is a clipped version of this face
+//-----------------------------------------------------------------------------
+void CMapFace::CreateFace(winding_t *w, int nFlags)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	AllocatePoints(w->numpoints);
+	for (int i = 0; i < nPoints; i++)
+	{
+		Points[i][0] = w->p[i][0];
+		Points[i][1] = w->p[i][1];
+		Points[i][2] = w->p[i][2];
+	}
+
+	if (!(nFlags & CREATE_FACE_PRESERVE_PLANE))
+	{
+		CalcPlaneFromFacePoints();
+	}
+
+    //
+    // Create a new displacement surface if the clipped surfaces is a quad.
+    //
+	// This assumes it is being called by the clipper!!! (Bad assumption).
+	//
+    if( HasDisp() && ( nFlags & CREATE_FACE_CLIPPING ) )
+	{
+		if ( nPoints == 4 )
+		{
+			// Setup new displacement surface.
+			EditDispHandle_t hClipDisp = EditDispMgr()->Create();
+			CMapDisp *pClipDisp = EditDispMgr()->GetDisp( hClipDisp );
+			
+			// Get older displacement surface.
+			EditDispHandle_t hDisp = GetDisp();
+			CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );
+			
+			// Init new displacement surface.
+			pClipDisp->SetParent( this );
+
+			// Apply the new displacement to this face, but keep the old one
+			// around -- we need it for the split operation.
+			SetDisp( hClipDisp, false );
+			pClipDisp->InitData( pDisp->GetPower() );
+			
+			// Calculate texture coordinates before splitting because we
+			// need the texture coords during the split.
+			CalcTextureCoords();
+
+			// Split the old displacement and put the results into hClipDisp.
+			pDisp->Split( hClipDisp );
+
+			// Delete the old displacement that was on this face.
+			EditDispMgr()->Destroy( hDisp );
+		}
+		else
+		{
+			SetDisp( EDITDISPHANDLE_INVALID );
+		}
+    }
+	else
+	{
+		CalcTextureCoords();
+	}
+#ifdef ENSUREDETAILS
+	// Create any detail objects if appropriate
+	DetailObjects::BuildAnyDetailObjects(this);
+#endif
+
+#ifdef DEBUGPTS
+	DebugPoints();
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Allocates space in Points array for nPoints worth of Vectors and
+//			the corresponding texture and lightmap coordinates (Vector2D's). Frees
+//			current points if there are any.
+// Input  : _nPoints - number of points needed.
+// Output : Total size of memory used by the points, texture, and lightmap coordinates.
+//-----------------------------------------------------------------------------
+size_t CMapFace::AllocatePoints(int _nPoints)
+{
+	//
+	// If we have already allocated this many points, do nothing.
+	//
+	if ((Points != NULL) && (_nPoints == nPoints))
+	{
+		return(nPoints * (sizeof(Vector) + sizeof(Vector2D) + sizeof(Vector2D)));
+	}
+
+	//
+	// If we have the wrong number of points allocated, free the memory.
+	//
+	if (Points != NULL)
+	{
+		delete [] Points;
+		Points = NULL;
+
+		delete [] m_pTextureCoords;
+		m_pTextureCoords = NULL;
+
+		delete [] m_pLightmapCoords;
+		m_pLightmapCoords = NULL;
+	}
+
+	Assert( nPoints == 0 || nPoints > 2 );
+
+	nPoints = _nPoints;
+
+	if (!_nPoints)
+	{
+		return(0);
+	}
+	
+	//
+	// Allocate the correct number of points, texture coords, and lightmap coords.
+	//
+	Points = new Vector[nPoints];
+	m_pTextureCoords = new Vector2D[nPoints];
+	m_pLightmapCoords = new Vector2D[nPoints];
+
+	// dvs: check for failure here and report an out of memory error
+	Assert(Points != NULL);
+	Assert(m_pTextureCoords != NULL);
+	Assert(m_pLightmapCoords != NULL);
+
+	return(nPoints * (sizeof(Vector) + sizeof(Vector2D) + sizeof(Vector2D)));
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pTexture - 
+//-----------------------------------------------------------------------------
+void CMapFace::SetTexture(IEditorTexture *pTexture, bool bRescaleTextureCoordinates)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	if ( m_pTexture && pTexture && bRescaleTextureCoordinates )
+	{
+		float flXFactor = (float)m_pTexture->GetWidth() / pTexture->GetWidth();
+		float flYFactor = (float)m_pTexture->GetHeight() / pTexture->GetHeight();
+
+		texture.scale[0] *= flXFactor;
+		texture.scale[1] *= flYFactor;
+
+		texture.UAxis[3] /= flXFactor;
+		texture.VAxis[3] /= flYFactor;
+	}
+
+	m_pTexture = pTexture;
+
+	// Copy other things from m_pTexture.
+	m_pTexture->GetShortName(texture.texture);
+	texture.q2surface = m_pTexture->GetSurfaceAttributes();
+	texture.q2contents = m_pTexture->GetSurfaceContents();
+
+	BOOL bTexValid = FALSE;
+	if (m_pTexture != NULL)
+	{
+		// Insure that the texture is loaded.
+		m_pTexture->Load();
+
+		bTexValid = !(
+			m_pTexture->GetWidth() == 0 || 
+			m_pTexture->GetHeight() == 0 ||
+			m_pTexture->GetImageWidth() == 0 ||
+			m_pTexture->GetImageHeight() == 0 || 
+			!m_pTexture->HasData()
+		);
+	}
+	
+	if (bTexValid)
+	{
+		CalcTextureCoords();
+	}
+
+	UpdateFaceFlags();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets this face's texture by name.
+// Input  : pszNewTex - Short name of texture to apply to this face.
+//-----------------------------------------------------------------------------
+void CMapFace::SetTexture(const char *pszNewTex, bool bRescaleTextureCoordinates)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	IEditorTexture *pTexture = g_Textures.FindActiveTexture(pszNewTex);
+	SetTexture(pTexture, bRescaleTextureCoordinates);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapFace::CalcTextureCoordAtPoint( const Vector& pt, Vector2D &texCoord )
+{
+	// sanity check
+	if( m_pTexture == NULL )
+		return;
+
+	//
+	// projected s, t (u, v) texture coordinates
+	//
+	float s = DotProduct( texture.UAxis.AsVector3D(), pt ) / texture.scale[0] + texture.UAxis[3];
+	float t = DotProduct( texture.VAxis.AsVector3D(), pt ) / texture.scale[1] + texture.VAxis[3];
+
+	//
+	// "normalize" the texture coordinates
+	//
+	if (m_pTexture->GetWidth())
+		texCoord[0] = s / ( float )m_pTexture->GetWidth();
+	else
+		texCoord[0] = 0.0;
+	
+	if (m_pTexture->GetHeight())
+		texCoord[1] = t / ( float )m_pTexture->GetHeight();
+	else
+		texCoord[1] = 0.0;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapFace::CalcLightmapCoordAtPoint( const Vector& pt, Vector2D &lightCoord )
+{
+	lightCoord[0] = DotProduct( texture.UAxis.AsVector3D(), pt ) / texture.nLightmapScale + 0.5f;
+	lightCoord[1] = DotProduct( texture.VAxis.AsVector3D(), pt ) / texture.nLightmapScale + 0.5f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculates the U,V texture coordinates of all points on this face.
+//-----------------------------------------------------------------------------
+void CMapFace::CalcTextureCoords(void)
+{
+	float s, t;
+	int i;
+
+	if (m_pTexture == NULL)
+	{
+		return;
+	}
+
+	//
+	// Make sure that scales are nonzero.
+	//
+	if (texture.scale[0] == 0)
+	{
+		texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
+	}
+
+	if (texture.scale[1] == 0)
+	{
+		texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
+	}
+
+	//
+	// Recalculate U,V coordinates for all points.
+	//
+	for (i = 0; i < nPoints; i++)
+	{
+		//
+		// Generate texture coordinates.
+		//
+		s = DotProduct(texture.UAxis.AsVector3D(), Points[i]) / texture.scale[0] + texture.UAxis[3];
+		t = DotProduct(texture.VAxis.AsVector3D(), Points[i]) / texture.scale[1] + texture.VAxis[3];
+
+		if (m_pTexture->GetWidth())
+			m_pTextureCoords[i][0] = s / (float)m_pTexture->GetWidth();
+		else
+			m_pTextureCoords[i][0] = 0.0f;
+
+		if (m_pTexture->GetHeight())
+			m_pTextureCoords[i][1] = t / (float)m_pTexture->GetHeight();
+ 		else
+			m_pTextureCoords[i][1] = 0.0f;
+
+		//
+		// Generate lightmap coordinates.  Lightmap coordinates for displacements happens below.
+		//
+		if ( m_DispHandle == EDITDISPHANDLE_INVALID )
+		{
+			float shiftScaleU = texture.scale[0] / (float)texture.nLightmapScale;
+			float shiftScaleV = texture.scale[1] / (float)texture.nLightmapScale;
+
+			m_pLightmapCoords[i][0] = DotProduct(texture.UAxis.AsVector3D(), Points[i]) / texture.nLightmapScale + texture.UAxis[3] * shiftScaleU + 0.5;
+			m_pLightmapCoords[i][1] = DotProduct(texture.VAxis.AsVector3D(), Points[i]) / texture.nLightmapScale + texture.VAxis[3] * shiftScaleV + 0.5;
+		}
+ 	}
+
+	//
+    // update the displacement map with new texture coordinates and calculate lightmap coordinates
+	//
+	if( ( m_DispHandle != EDITDISPHANDLE_INVALID ) && nPoints == 4 )
+    {
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		pDisp->InitDispSurfaceData( this, false );
+		pDisp->Create();
+    }
+
+	// re-calculate the tangent space
+	CalcTangentSpaceAxes();
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the max lightmap size for this face
+//-----------------------------------------------------------------------------
+int CMapFace::MaxLightmapSize() const
+{
+	return HasDisp() ? MAX_DISP_LIGHTMAP_DIM_WITHOUT_BORDER : MAX_BRUSH_LIGHTMAP_DIM_WITHOUT_BORDER;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks the validity of this face.
+// Input  : pInfo - 
+// Output : Returns TRUE on success, FALSE on failure.
+//-----------------------------------------------------------------------------
+BOOL CMapFace::CheckFace(CCheckFaceInfo *pInfo)
+{
+	if (!::CheckFace(Points, nPoints, &plane.normal, plane.dist, pInfo))
+	{
+		return(FALSE);
+	}
+
+	//
+	// Check for duplicate plane points. All three plane points must be unique
+	// or it isn't a valid plane.
+	//
+	for (int nPlane = 0; nPlane < 3; nPlane++)
+	{
+		for (int nPlaneCheck = 0; nPlaneCheck < 3; nPlaneCheck++)
+		{
+			if (nPlane != nPlaneCheck)
+			{
+				if (VectorCompare(plane.planepts[nPlane], plane.planepts[nPlaneCheck]))
+				{
+					if (pInfo != NULL)
+					{
+						strcpy(pInfo->szDescription, "face has duplicate plane points");
+					}
+					return(FALSE);		
+				}
+			}
+		}
+	}
+
+	return(TRUE);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Included for loading old (quake-style) maps. This sets up the texture axes
+//			the same way QCSG and pre-2.2 Hammer did.
+// Input  : UAxis - 
+//			VAxis - 
+//-----------------------------------------------------------------------------
+void CMapFace::InitializeQuakeStyleTextureAxes(Vector4D& UAxis, Vector4D& VAxis)
+{
+	static Vector baseaxis[18] =
+	{
+		Vector(0,0,1), Vector(1,0,0), Vector(0,-1,0),			// floor
+		Vector(0,0,-1), Vector(1,0,0), Vector(0,-1,0),		// ceiling
+		Vector(1,0,0), Vector(0,1,0), Vector(0,0,-1),			// west wall
+		Vector(-1,0,0), Vector(0,1,0), Vector(0,0,-1),		// east wall
+		Vector(0,1,0), Vector(1,0,0), Vector(0,0,-1),			// south wall
+		Vector(0,-1,0), Vector(1,0,0), Vector(0,0,-1)			// north wall
+	};
+
+	int		bestaxis;
+	vec_t	dot,best;
+	int		i;
+	
+	best = 0;
+	bestaxis = 0;
+	
+	for (i=0 ; i<6 ; i++)
+	{
+		dot = DotProduct(plane.normal, baseaxis[i*3]);
+		if (dot > best)
+		{
+			best = dot;
+			bestaxis = i;
+		}
+	}
+	
+	UAxis.AsVector3D() = baseaxis[bestaxis * 3 + 1];
+	VAxis.AsVector3D() = baseaxis[bestaxis * 3 + 2];
+}
+
+
+//-----------------------------------------------------------------------------
+// Should we render this lit or not
+//-----------------------------------------------------------------------------
+void CMapFace::RenderUnlit( bool enable )
+{
+	m_bIgnoreLighting = enable;
+}
+
+
+
+inline void Modulate( Color &pColor, float f )
+{
+	pColor[0] *= f;
+	pColor[1] *= f;
+	pColor[2] *= f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the color and texture to use
+//-----------------------------------------------------------------------------
+
+void CMapFace::ComputeColor( CRender3D* pRender, bool bRenderAsSelected,
+							 SelectionState_t faceSelectionState,
+							 bool ignoreLighting, Color &pColor )
+{
+	EditorRenderMode_t eCurrentRenderMode = pRender->GetCurrentRenderMode();
+	
+	// White w/alpha by default
+	pColor[0] = pColor[1] = pColor[2] = 255;
+	pColor[3] = m_uchAlpha;
+
+	float fShade;
+	if (!ignoreLighting)
+		fShade = pRender->LightPlane(plane.normal);
+	else
+		fShade = 1.0;
+
+	switch (eCurrentRenderMode)
+	{
+	case RENDER_MODE_TEXTURED:
+	case RENDER_MODE_TEXTURED_SHADED:
+	case RENDER_MODE_LIGHT_PREVIEW2:
+	case RENDER_MODE_LIGHT_PREVIEW_RAYTRACED:
+		Modulate( pColor, fShade );
+		break;
+
+	case RENDER_MODE_SELECTION_OVERLAY:
+		if( faceSelectionState == SELECT_MULTI_PARTIAL )
+		{
+			pColor[2] = 100;
+			pColor[3] = 64;
+		}
+		else if( ( faceSelectionState == SELECT_NORMAL ) || bRenderAsSelected )
+		{
+			SelectFaceColor( pColor );
+			pColor[3] = 64;
+		}
+		break;
+
+	case RENDER_MODE_LIGHTMAP_GRID:
+		if (bRenderAsSelected)
+		{
+			SelectFaceColor( pColor );
+		}
+		else if (texture.nLightmapScale > DEFAULT_LIGHTMAP_SCALE)
+		{
+			pColor[0] = 150;
+		}
+		else if (texture.nLightmapScale < DEFAULT_LIGHTMAP_SCALE)
+		{
+			pColor[2] = 100;
+		}
+
+		Modulate( pColor, fShade );
+		break;
+
+	case RENDER_MODE_TRANSLUCENT_FLAT:
+	case RENDER_MODE_FLAT:
+		if (bRenderAsSelected)
+			SelectFaceColor( pColor );
+		else
+			pColor.SetColor( r,g,b,m_uchAlpha );
+								
+		Modulate( pColor, fShade );
+		break;
+
+	case RENDER_MODE_WIREFRAME:
+		if (bRenderAsSelected)
+			SelectEdgeColor( pColor );
+		else
+			pColor.SetColor( r,g,b,m_uchAlpha );
+		
+		break;
+
+	case RENDER_MODE_SMOOTHING_GROUP:
+		{
+			// Render the non-smoothing group faces in white, yellow for the others.
+			CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
+			if ( pDoc )
+			{
+				int iGroup = pDoc->GetSmoothingGroupVisual();
+				if ( InSmoothingGroup( iGroup ) )
+				{
+					pColor[2] = 0;
+				}
+			}
+
+			Modulate( pColor, fShade );
+			break;
+		}
+
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+static bool ModeUsesTextureCoords(EditorRenderMode_t mode)
+{
+	return (
+		(mode == RENDER_MODE_TEXTURED) ||
+		(mode == RENDER_MODE_LIGHTMAP_GRID) || 
+		(mode == RENDER_MODE_TEXTURED_SHADED) ||
+		(mode == RENDER_MODE_LIGHT_PREVIEW2) ||
+		(mode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
+		);
+}
+
+//-----------------------------------------------------------------------------
+// Draws the face using the material system material
+//-----------------------------------------------------------------------------
+void CMapFace::DrawFace( Color &pColor, EditorRenderMode_t mode )
+{
+	// retrieve the coordinate frame to render into 
+	// (most likely just the identity, unless we're animating)
+	VMatrix frame;
+	bool hasParent = GetTransformMatrix( frame );
+
+	// don't do this -- if you use the material system to rotate and/or translate
+	// this will cull the locally spaced object!! -- need to pass around a flag!
+#if 0 
+	// A little culling....
+	float fEyeDot = DotProduct(plane.normal, ViewPoint);
+	if ((fEyeDot < plane.dist) && (mode != RENDER_MODE_WIREFRAME) && !hasParent && 
+		(m_uchAlpha == 255))
+	{
+		return;
+	}
+#endif
+
+
+	// don't draw no draws in ray tracced mode
+	if ( mode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED )
+	{
+		if ( m_nFaceFlags & FACE_FLAGS_NODRAW_IN_LPREVIEW )
+			return;
+	}
+
+
+	MaterialPrimitiveType_t type = (mode == RENDER_MODE_WIREFRAME) ? 
+		MATERIAL_LINE_LOOP : MATERIAL_POLYGON; 
+
+	CMeshBuilder meshBuilder;
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+	meshBuilder.Begin( pMesh, type, nPoints );
+    
+    for (int nPoint = 0; nPoint < nPoints; nPoint++)
+    {
+		if (ModeUsesTextureCoords(mode))
+		{
+			meshBuilder.TexCoord2f( 0, m_pTextureCoords[nPoint][0], m_pTextureCoords[nPoint][1] );
+			meshBuilder.TexCoord2f( 1, m_pLightmapCoords[nPoint][0], m_pLightmapCoords[nPoint][1]);
+		}
+
+		meshBuilder.Color4ubv( (byte*)&pColor );
+
+        // transform into absolute space
+        if ( hasParent )
+        {
+            Vector point;
+            VectorTransform( Points[nPoint], frame.As3x4(), point );
+            meshBuilder.Position3f(point[0], point[1], point[2]);
+        }
+        else
+        {
+            meshBuilder.Position3f(Points[nPoint][0], Points[nPoint][1], Points[nPoint][2]);
+        }
+
+		// FIXME: no smoothing group information
+		meshBuilder.Normal3fv(plane.normal.Base());
+		meshBuilder.TangentS3fv( m_pTangentAxes[nPoint].tangent.Base() );
+		meshBuilder.TangentT3fv( m_pTangentAxes[nPoint].binormal.Base() );
+
+		meshBuilder.AdvanceVertex();
+    }
+    
+    meshBuilder.End();
+	pMesh->Draw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Renders the grid on the face
+//-----------------------------------------------------------------------------
+void CMapFace::RenderGridIfCloseEnough( CRender3D* pRender )
+{
+	CMapFace *pThis = this;
+	RenderGridsIfCloseEnough( pRender, 1, &pThis );
+}
+
+
+//-----------------------------------------------------------------------------
+// renders the texture axes
+//-----------------------------------------------------------------------------
+void CMapFace::RenderTextureAxes( CRender3D* pRender )
+{
+	CMapFace *pThis = this;
+	RenderTextureAxes( pRender, 1, &pThis );
+}
+
+
+//-----------------------------------------------------------------------------
+// for sorting
+//-----------------------------------------------------------------------------
+bool CMapFace::ShouldRenderLast()
+{
+	if (!m_pTexture || !m_pTexture->GetMaterial())
+		return false;
+
+	return m_pTexture->GetMaterial()->IsTranslucent() || (m_uchAlpha != 255) ;
+}
+
+//-----------------------------------------------------------------------------
+// render texture axes
+//-----------------------------------------------------------------------------
+void CMapFace::RenderTextureAxes( CRender3D* pRender, int nCount, CMapFace **ppFaces )
+{
+	// Render the world axes.
+	pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
+
+	CMeshBuilder meshBuilder;
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+	meshBuilder.Begin( pMesh, MATERIAL_LINES, 2 * nCount );
+
+	Vector Center;
+	for ( int i = 0; i < nCount; ++i )
+	{
+		ppFaces[i]->GetCenter(Center);
+
+		meshBuilder.Color3ub(255, 255, 0);
+		meshBuilder.Position3f(Center[0], Center[1], Center[2]);
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3ub(255, 255, 0);
+		meshBuilder.Position3f(Center[0] + ppFaces[i]->texture.UAxis[0] * TEXTURE_AXIS_LENGTH, 
+			Center[1] + ppFaces[i]->texture.UAxis[1] * TEXTURE_AXIS_LENGTH, 
+			Center[2] + ppFaces[i]->texture.UAxis[2] * TEXTURE_AXIS_LENGTH);
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3ub(0, 255, 0);
+		meshBuilder.Position3f(Center[0], Center[1], Center[2]);
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3ub(0, 255, 0);
+		meshBuilder.Position3f(Center[0] + ppFaces[i]->texture.VAxis[0] * TEXTURE_AXIS_LENGTH, 
+			Center[1] + ppFaces[i]->texture.VAxis[1] * TEXTURE_AXIS_LENGTH, 
+			Center[2] + ppFaces[i]->texture.VAxis[2] * TEXTURE_AXIS_LENGTH);
+		meshBuilder.AdvanceVertex();
+	}
+		
+	meshBuilder.End();
+	pMesh->Draw();
+
+	pRender->PopRenderMode();
+}
+
+
+//-----------------------------------------------------------------------------
+// Render grids
+//-----------------------------------------------------------------------------
+void CMapFace::Render3DGrids( CRender3D *pRender, int nCount, CMapFace **ppFaces )
+{
+	// FIXME: Optimize this to render all of them in a single call
+	for ( int i = 0; i < nCount; ++i )
+	{
+		ppFaces[i]->Render3DGrid( pRender );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Render grids
+//-----------------------------------------------------------------------------
+void CMapFace::RenderGridsIfCloseEnough( CRender3D* pRender, int nCount, CMapFace **ppFaces )
+{
+	// If the 3D grid is enabled and we aren't picking, 
+	// render the grid on this face.
+	if ( (!pRender->IsEnabled(RENDER_GRID)) || pRender->IsPicking() )
+		return;
+
+	Vector Maxs;
+	Vector Mins;
+	float fGridSize = pRender->GetGridDistance();
+
+	Vector viewPoint; pRender->GetCamera()->GetViewPoint( viewPoint );
+
+	CMapFace **ppFinalList = (CMapFace**)_alloca( nCount * sizeof(CMapFace*) );
+	int nFinalCount = 0;
+	for ( int i = 0; i < nCount; ++i )
+	{
+		ppFaces[i]->GetFaceBounds(Mins, Maxs);
+
+		for ( int j = 0; j < 3; j++)
+		{
+			Mins[j] -= fGridSize;
+			Maxs[j] += fGridSize;
+		}
+
+		// Only render the grid if the face is close enough to the camera.
+		if ( IsPointInBox(viewPoint, Mins, Maxs) )
+		{
+			ppFinalList[nFinalCount++] = ppFaces[i];
+		}
+	}
+
+	Render3DGrids( pRender, nFinalCount, ppFinalList );
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a face's vertices to the meshbuilder
+//-----------------------------------------------------------------------------
+void CMapFace::AddFaceVertices( CMeshBuilder &meshBuilder, CRender3D* pRender, bool bRenderSelected, SelectionState_t faceSelectionState)
+{
+	Vector point;
+	VMatrix frame;
+	Color color;
+
+	bool bHasParent = GetTransformMatrix( frame );
+	ComputeColor( pRender, bRenderSelected, faceSelectionState, m_bIgnoreLighting, color );
+
+	for ( int nPoint = 0; nPoint < nPoints; nPoint++ )
+	{
+		if ( bHasParent )
+		{
+			// transform into absolute space
+			VectorTransform( Points[nPoint], frame.As3x4(), point );
+			meshBuilder.Position3fv( point.Base() );
+		}
+		else
+		{
+			meshBuilder.Position3fv( Points[nPoint].Base() );
+		}
+
+		meshBuilder.Normal3fv( plane.normal.Base() );
+		meshBuilder.Color4ubv( (byte*)&color );
+
+		meshBuilder.TexCoord2fv( 0, m_pTextureCoords[nPoint].Base() );
+		meshBuilder.TexCoord2fv( 1, m_pLightmapCoords[nPoint].Base() );
+		meshBuilder.TangentS3fv( m_pTangentAxes[nPoint].tangent.Base() );
+		meshBuilder.TangentT3fv( m_pTangentAxes[nPoint].binormal.Base() );
+
+		meshBuilder.AdvanceVertex();
+	}
+}
+
+
+struct MapFaceRender_t
+{
+	bool m_RenderSelected;
+	EditorRenderMode_t m_RenderMode;
+	IEditorTexture* m_pTexture;
+	CMapFace* m_pMapFace;
+	SelectionState_t m_FaceSelectionState;
+};
+
+typedef CUtlRBTree<MapFaceRender_t, int>	FaceQueue_t;
+
+
+//-----------------------------------------------------------------------------
+// draws a list of faces in wireframe
+//-----------------------------------------------------------------------------
+void CMapFace::RenderWireframeFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces )
+{
+
+	// Draw the texture axes
+	int nAxesCount = 0;
+	CMapFace **ppAxesFaces = (CMapFace**)_alloca( nCount * sizeof(CMapFace*) );
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( ppFaces[i]->m_FaceSelectionState != SELECT_NONE )
+		{
+			ppAxesFaces[ nAxesCount++ ] = ppFaces[i]->m_pMapFace;
+		}
+	}
+
+	if ( nAxesCount != 0 )
+	{
+		RenderTextureAxes( pRender, nAxesCount, ppAxesFaces );
+	}
+
+	if ( pRender->IsEnabled(RENDER_GRID) )
+	{
+		// Draw the grid
+		CMapFace **ppGridFaces = (CMapFace**)_alloca( nCount * sizeof(CMapFace*) );
+		for ( int i = 0; i < nCount; ++i )
+		{
+			ppGridFaces[i] = ppFaces[i]->m_pMapFace;
+		}
+
+		RenderGridsIfCloseEnough( pRender, nCount, ppGridFaces );
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+// Draws a batch of faces.
+//-----------------------------------------------------------------------------
+void CMapFace::RenderFacesBatch( CMeshBuilder &meshBuilder, IMesh* pMesh, CRender3D* pRender, MapFaceRender_t **ppFaces, int nFaceCount, int nVertexCount, int nIndexCount, bool bWireframe )
+{
+	if ( bWireframe )
+	{
+		meshBuilder.Begin( pMesh, MATERIAL_LINES, nVertexCount, nIndexCount );
+	}
+	else
+	{
+		meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nVertexCount, nIndexCount );
+	}
+	
+	int nFirstVertex = 0;
+	
+	for ( int i = 0; i < nFaceCount; ++i )
+	{
+		CMapFace *pMapFace = ppFaces[i]->m_pMapFace;
+
+		pMapFace->AddFaceVertices( meshBuilder,	pRender, ppFaces[i]->m_RenderSelected, ppFaces[i]->m_FaceSelectionState );
+
+		int nPoints = pMapFace->GetPointCount();
+
+		if ( bWireframe )
+		{
+			meshBuilder.FastIndex( nFirstVertex );
+			for ( int j = 1; j < nPoints; ++j )
+			{
+				meshBuilder.FastIndex( nFirstVertex + j );
+				meshBuilder.FastIndex( nFirstVertex + j );
+			}
+			meshBuilder.FastIndex( nFirstVertex );
+		}
+		else
+		{
+			for ( int j = 2; j < nPoints; ++j )
+			{
+				meshBuilder.FastIndex( nFirstVertex );
+				meshBuilder.FastIndex( nFirstVertex + j - 1 );
+				meshBuilder.FastIndex( nFirstVertex + j );
+			}
+		}
+
+		nFirstVertex += nPoints;
+	}
+	
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Draws a list of faces, breaking them up into batches if necessary.
+//-----------------------------------------------------------------------------
+void CMapFace::RenderFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces )
+{
+	if ( nCount == 0 )
+		return;
+
+	bool bWireframe = ppFaces[0]->m_RenderMode == RENDER_MODE_WIREFRAME;
+
+	if ( RenderingModeIsTextured(ppFaces[0]->m_RenderMode))
+	{
+		pRender->BindTexture( ppFaces[0]->m_pTexture );
+	}
+
+	pRender->PushRenderMode( ppFaces[0]->m_RenderMode );
+
+	int nBatchStart = 0;
+	int nIndexCount = 0;
+	int nVertexCount = 0;
+
+	int nMaxVerts, nMaxIndices;
+
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+
+	pRenderContext->GetMaxToRender( pMesh, true, &nMaxVerts, &nMaxIndices );
+
+	// Make sure we have enough for at least one triangle...
+	int nMinVerts = ppFaces[0]->m_pMapFace->GetPointCount();
+	int nMinIndices = max( nMinVerts*2, (nMinVerts-2)*3 );
+	if ( nMaxVerts < nMinVerts || nMaxIndices < nMinIndices )
+	{
+		pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );
+	}
+
+	CMeshBuilder meshBuilder;	
+	for ( int nFace = 0; nFace < nCount; nFace++ )
+	{
+		Assert( ppFaces[nFace]->m_RenderMode == ppFaces[0]->m_RenderMode );
+		Assert( ppFaces[nFace]->m_pTexture == ppFaces[0]->m_pTexture );
+
+		int newIndices, newVertices = ppFaces[nFace]->m_pMapFace->GetPointCount();
+	
+		if( bWireframe )
+		{
+			newIndices = newVertices*2;
+		}
+		else
+		{
+			newIndices = (newVertices-2) * 3;
+		}
+		
+		if ( ( ( nVertexCount + newVertices ) > nMaxVerts ) || ( ( nIndexCount + newIndices )  > nMaxIndices ) )
+		{
+			// If we hit this assert, there's a single face that's too big for the meshbuilder to handle!
+			Assert( ( nFace - nBatchStart ) > 0 );
+		
+			// We have a full batch, render it.
+			
+			RenderFacesBatch( meshBuilder, pMesh, pRender, &ppFaces[nBatchStart], nFace - nBatchStart, nVertexCount, nIndexCount, bWireframe );
+
+			pRenderContext->GetMaxToRender( pMesh, false, &nMaxVerts, &nMaxIndices );
+
+			nBatchStart = nFace;
+			nVertexCount = 0;
+			nIndexCount = 0;
+		}
+
+		nVertexCount += newVertices;
+		nIndexCount += newIndices;
+	}
+
+	// Render whatever is left over.
+	RenderFacesBatch( meshBuilder, pMesh, pRender, &ppFaces[nBatchStart], nCount - nBatchStart, nVertexCount, nIndexCount, bWireframe );
+	
+	//render additional wireframe stuff
+	if ( bWireframe )
+	{
+		RenderWireframeFaces( pRender, nCount, ppFaces );
+	}
+
+	pRender->PopRenderMode();
+}
+
+
+//-----------------------------------------------------------------------------
+// draws a single face (displacement or normal)
+//-----------------------------------------------------------------------------
+void CMapFace::RenderFace3D( CRender3D* pRender, EditorRenderMode_t renderMode, bool renderSelected, SelectionState_t faceSelectionState )
+{
+	pRender->PushRenderMode( renderMode );
+
+	if ( HasDisp() && CMapDoc::GetActiveMapDoc() && CMapDoc::GetActiveMapDoc()->IsDispDraw3D() )
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		pDisp->Render3D( pRender, renderSelected, faceSelectionState );
+	}
+	else
+	{
+		Color color;
+		ComputeColor( pRender, renderSelected, faceSelectionState, m_bIgnoreLighting, color );
+  		DrawFace( color, renderMode );
+	}
+
+	// Draw the texture axes
+	if( renderMode == RENDER_MODE_WIREFRAME )
+	{
+		if (faceSelectionState != SELECT_NONE)
+			RenderTextureAxes(pRender);
+
+		// Draw the grid
+		RenderGridIfCloseEnough( pRender );
+	} 
+	else if ( m_pDetailObjects && Options.general.bShowDetailObjects )
+	{
+
+		// Only draw the detailed objects if the displacement/face is not currently selected.
+		pRender->AddTranslucentDeferredRendering( m_pDetailObjects );
+	}
+
+	pRender->PopRenderMode();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mode - 
+//-----------------------------------------------------------------------------
+static int SortVal(EditorRenderMode_t mode)
+{
+	if (mode == RENDER_MODE_WIREFRAME)
+		return 2;
+	if ( mode == RENDER_MODE_SELECTION_OVERLAY )
+		return 1;
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : s1 - 
+//			s2 - 
+// Output : 
+//-----------------------------------------------------------------------------
+static bool OpaqueFacesLessFunc( const MapFaceRender_t &s1, const MapFaceRender_t &s2 )
+{
+	// Render texture first, overlay second, wireframe 3rd
+	int nSort1 = SortVal(s1.m_RenderMode);
+	int nSort2 = SortVal(s2.m_RenderMode);
+	if (nSort1 < nSort2)
+		return true;
+	if (nSort1 > nSort2)
+		return false;
+
+	return s1.m_pTexture < s2.m_pTexture;
+}
+
+
+static FaceQueue_t g_OpaqueFaces(0, 0, OpaqueFacesLessFunc);
+static CUtlVector< FaceQueue_t * >	g_OpaqueInstanceFaces;
+static FaceQueue_t *g_CurrentOpaqueFaces = &g_OpaqueFaces;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function will add the face to the sorted current queue
+// Input  : pMapFace - the face to be added
+//			pTexture - the texture of the face
+//			renderMode - what type of rendering mode
+//			selected - if it is selected or not ( selected appears on top )
+//			faceSelectionState - if the face is individual selected
+//-----------------------------------------------------------------------------
+void CMapFace::AddFaceToQueue( CMapFace* pMapFace, IEditorTexture* pTexture, EditorRenderMode_t renderMode, bool selected, SelectionState_t faceSelectionState )
+{
+	MapFaceRender_t newEntry;
+	newEntry.m_RenderMode = renderMode;
+	newEntry.m_pTexture = pTexture;
+	newEntry.m_RenderSelected = selected;
+	newEntry.m_pMapFace = pMapFace;
+	newEntry.m_FaceSelectionState = faceSelectionState;
+	g_CurrentOpaqueFaces->Insert( newEntry );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function will add a new face queue to the top of the list and 
+//			make it active
+//-----------------------------------------------------------------------------
+void CMapFace::PushFaceQueue( void )
+{
+	g_OpaqueInstanceFaces.AddToHead( new FaceQueue_t( 0, 0, OpaqueFacesLessFunc ) );
+
+	g_CurrentOpaqueFaces = g_OpaqueInstanceFaces.Head();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function will pop the top face queue off the list
+//-----------------------------------------------------------------------------
+void CMapFace::PopFaceQueue( void )
+{
+	Assert( g_OpaqueInstanceFaces.Count() > 0 );
+
+	FaceQueue_t *pHead = g_OpaqueInstanceFaces.Head();
+
+	g_OpaqueInstanceFaces.Remove( 0 );
+	delete pHead;
+
+	if ( g_OpaqueInstanceFaces.Count() )
+	{
+		g_CurrentOpaqueFaces = g_OpaqueInstanceFaces.Head();
+	}
+	else
+	{
+		g_CurrentOpaqueFaces = &g_OpaqueFaces;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// renders queued up opaque faces, sorted by material
+//-----------------------------------------------------------------------------
+void CMapFace::RenderOpaqueFaces( CRender3D* pRender )
+{
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+
+	MapFaceRender_t **ppMapFaces = (MapFaceRender_t**)_alloca( g_CurrentOpaqueFaces->Count() * sizeof( MapFaceRender_t* ) );
+	int nFaceCount = 0;
+
+	int nLastRenderMode = RENDER_MODE_NONE;
+	IEditorTexture *pLastTexture = NULL;
+
+	for ( int i = g_CurrentOpaqueFaces->FirstInorder(); i != g_CurrentOpaqueFaces->InvalidIndex(); i = g_CurrentOpaqueFaces->NextInorder(i) )
+	{
+		MapFaceRender_t& mapFace = ( *g_CurrentOpaqueFaces)[i];
+
+		if ( ( mapFace.m_RenderMode != nLastRenderMode ) || ( mapFace.m_pTexture != pLastTexture ) )
+		{
+			RenderFaces( pRender, nFaceCount, ppMapFaces );
+			nFaceCount = 0;
+		}
+
+		if ( mapFace.m_pMapFace->HasDisp() )
+		{
+			if ( RenderingModeIsTextured( mapFace.m_RenderMode ))
+			{
+				pRender->BindTexture( mapFace.m_pTexture );
+			}
+
+			mapFace.m_pMapFace->RenderFace3D( pRender, mapFace.m_RenderMode, mapFace.m_RenderSelected, mapFace.m_FaceSelectionState );
+		}
+		else
+		{
+			ppMapFaces[ nFaceCount++ ] = &mapFace;
+			nLastRenderMode = mapFace.m_RenderMode;
+		    pLastTexture = mapFace.m_pTexture;
+		}
+	}
+
+	RenderFaces( pRender, nFaceCount, ppMapFaces ); 
+
+	g_CurrentOpaqueFaces->RemoveAll();
+}
+
+
+void CMapFace::Render2D(CRender2D *pRender)
+{	
+	SelectionState_t eFaceSelectionState = GetSelectionState();
+	SelectionState_t eSolidSelectionState;
+	if (m_pParent != NULL)
+	{
+		eSolidSelectionState = m_pParent->GetSelectionState();
+	}
+	else
+	{
+		eSolidSelectionState = eFaceSelectionState;
+	}
+
+	bool bRenderSelected = ( eSolidSelectionState != SELECT_NONE );
+	bRenderSelected = bRenderSelected || ( ( eFaceSelectionState != SELECT_NONE ) && (CMapFace::m_bShowFaceSelection) );
+
+	Vector vViewNormal; pRender->GetCamera()->GetViewForward( vViewNormal );
+	Vector vNormal; GetFaceNormal( vNormal );
+
+	// if face is parallel to view axis, skip it
+	bool bIsParallel = ( fabs( vViewNormal.Dot( vNormal) ) < 0.0001f );
+		
+	if ( HasDisp() && ( bIsParallel || bRenderSelected ) )
+	{
+		Vector mins,maxs;
+
+		GetRender2DBox( mins,maxs );
+
+		Vector2D pt,pt2;
+		pRender->TransformPoint(pt, mins );
+		pRender->TransformPoint(pt2, maxs );
+
+		int sizeX = abs(pt2.x-pt.x);
+		int sizeY = abs(pt2.y-pt.y);
+
+		bool bDrawDispMap = Options.view2d.bDrawModels && ( (sizeX+sizeY) > 50 || bRenderSelected );
+
+		if ( bDrawDispMap )
+		{
+			CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+			pDisp->Render2D( pRender, bRenderSelected, eFaceSelectionState );
+			return;
+		}
+	}
+	
+	if ( !bIsParallel )
+	{
+		pRender->DrawPolyLine( nPoints, Points );
+	}
+}
+
+void CMapFace::RenderVertices(CRender *pRender)
+{
+	for ( int i=0; i< nPoints;i++ )
+		pRender->DrawHandle( Points[i] );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders this face using the given 3D renderer.
+// Input  : pRender - Renderer to draw with. 
+//-----------------------------------------------------------------------------
+void CMapFace::Render3D( CRender3D *pRender )
+{
+	if (nPoints == 0)
+	{
+		return;
+	}
+
+	//
+	// Skip back faces unless rendering in wireframe.
+	//
+	EditorRenderMode_t eCurrentRenderMode = pRender->GetCurrentRenderMode();
+
+	if ( eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED )
+	{
+		if ( m_nFaceFlags & FACE_FLAGS_NODRAW_IN_LPREVIEW )
+			return;
+	}
+
+	SelectionState_t eFaceSelectionState = GetSelectionState();
+	SelectionState_t eSolidSelectionState;
+	if (m_pParent != NULL)
+	{
+		eSolidSelectionState = m_pParent->GetSelectionState();
+	}
+	else
+	{
+		eSolidSelectionState = eFaceSelectionState;
+	}
+
+	if ( !Options.general.bShowNoDrawBrushes && eSolidSelectionState == SELECT_NONE && m_pTexture == g_Textures.GetNoDrawTexture() )
+		return;
+
+	//
+	// Draw the face.
+	//
+	bool renderSelected = ( ( eSolidSelectionState != SELECT_NONE ) );
+	renderSelected = renderSelected || ( ( eFaceSelectionState != SELECT_NONE ) && (CMapFace::m_bShowFaceSelection) );
+
+	if (pRender->DeferRendering())
+	{
+		AddFaceToQueue( this, m_pTexture, eCurrentRenderMode, renderSelected, eFaceSelectionState );
+		if ( ( renderSelected && pRender->NeedsOverlay() ) )
+		{
+			AddFaceToQueue( this, m_pTexture, RENDER_MODE_SELECTION_OVERLAY, renderSelected, eFaceSelectionState );
+		}
+
+	}
+	else
+	{
+		// Set up the texture to use
+		pRender->BindTexture( m_pTexture );
+
+		RenderFace3D( pRender, eCurrentRenderMode, renderSelected, eFaceSelectionState );
+		if ( ( renderSelected && pRender->NeedsOverlay() ) )
+		{
+			RenderFace3D( pRender, RENDER_MODE_SELECTION_OVERLAY, renderSelected, eFaceSelectionState );
+		}
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders the world grid projected onto the given face.
+// Input  : pFace - The face onto which the grid will be projected.
+//-----------------------------------------------------------------------------
+void CMapFace::Render3DGrid(CRender3D *pRender)
+{
+	//
+	// Determine the extents of this face.
+	//
+	Extents_t Extents;
+	float fDelta[3];
+	float fGridSpacing = pRender->GetGridSize();
+
+	GetFaceExtents(Extents);
+
+	fDelta[0] = Extents[EXTENTS_XMAX][0] - Extents[EXTENTS_XMIN][0];
+	fDelta[1] = Extents[EXTENTS_YMAX][1] - Extents[EXTENTS_YMIN][1];
+	fDelta[2] = Extents[EXTENTS_ZMAX][2] - Extents[EXTENTS_ZMIN][2];
+
+	//
+	// Render the grid lines with wireframe material.
+	//
+	pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
+
+	CMeshBuilder meshBuilder;
+	CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh();
+
+	//
+	// For every dimension in which this face has a nonzero projection.
+	//
+	for (int nDim = 0; nDim < 3; nDim++)
+	{
+		if (fDelta[nDim] != 0)
+		{
+			Vector Normal;
+
+			Normal[0] = (float)((nDim  % 3) == 0);
+			Normal[1] = (float)((nDim  % 3) == 1);
+			Normal[2] = (float)((nDim  % 3) == 2);
+
+			float fMin = Extents[nDim * 2][nDim];
+			float fMax = Extents[(nDim * 2) + 1][nDim];
+
+			float fStart = (float)(floor(fMin / fGridSpacing) * fGridSpacing);
+			float fEnd = (float)(ceil(fMax / fGridSpacing) * fGridSpacing);
+
+			float fGridPoint = fStart;
+
+			while (fGridPoint < fEnd)
+			{
+				int nPointsFound = 0;
+
+				//
+				// For every edge.
+				//
+				for (int nPoint = 0; nPoint < nPoints; nPoint++)
+				{
+					Vector PointFound[2];
+
+					//
+					// Get the start and end points of the edge.
+					//
+					Vector Point1 = Points[nPoint];
+
+					Vector Point2;
+					if (nPoint < nPoints - 1)
+					{
+						Point2 = Points[nPoint + 1];
+					}
+					else
+					{
+						Point2 = Points[0];
+					}
+
+					// 
+					// If there is a projection of the normal vector along this edge.
+					//
+					if (Point2[nDim] != Point1[nDim])
+					{
+						//
+						// Solve for the point along this edge that intersects the grid line
+						// as a parameter from zero to one.
+						//
+						float fScale = (fGridPoint - Point1[nDim]) / (Point2[nDim] - Point1[nDim]);
+						if ((fScale >= 0) && (fScale <= 1))
+						{
+							PointFound[nPointsFound][0] = Point1[0] + (Point2[0] - Point1[0]) * fScale;
+							PointFound[nPointsFound][1] = Point1[1] + (Point2[1] - Point1[1]) * fScale;
+							PointFound[nPointsFound][2] = Point1[2] + (Point2[2] - Point1[2]) * fScale;
+
+							nPointsFound++;
+
+							if (nPointsFound == 2)
+							{
+								Vector RenderPoint;
+
+								meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
+
+								VectorMA(PointFound[0], 0.2, plane.normal, RenderPoint);
+								meshBuilder.Position3f(RenderPoint[0], RenderPoint[1], RenderPoint[2]);
+								meshBuilder.Color3ub(Normal[0] * 255, Normal[1] * 255, Normal[2] * 255);
+								meshBuilder.AdvanceVertex();
+
+								VectorMA(PointFound[1], 0.2, plane.normal, RenderPoint);
+								meshBuilder.Position3f(RenderPoint[0], RenderPoint[1], RenderPoint[2]);
+								meshBuilder.Color3ub(Normal[0] * 255, Normal[1] * 255, Normal[2] * 255);
+								meshBuilder.AdvanceVertex();
+
+								meshBuilder.End();
+								pMesh->Draw();
+
+								nPointsFound = 0;
+							}
+						}
+					}
+				}
+			
+				fGridPoint += fGridSpacing;
+			}
+		}
+	}
+
+	pRender->PopRenderMode();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pLoadInfo - 
+//			pFace - 
+// Output : ChunkFileResult_t
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CMapFace::LoadDispInfoCallback(CChunkFile *pFile, CMapFace *pFace)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	// allocate a displacement (for the face)
+	EditDispHandle_t dispHandle = EditDispMgr()->Create();
+	CMapDisp *pDisp = EditDispMgr()->GetDisp( dispHandle );	
+
+	//
+	// load the displacement info and set relationships
+	//
+	ChunkFileResult_t eResult = pDisp->LoadVMF( pFile );
+	if( eResult == ChunkFile_Ok )
+	{
+		pDisp->SetParent( pFace );
+		pFace->SetDisp( dispHandle );
+
+		CMapWorld *pWorld = GetActiveWorld();
+		if( pWorld )
+		{
+			IWorldEditDispMgr *pDispMgr = pWorld->GetWorldEditDispManager();
+			if( pDispMgr )
+			{
+				pDispMgr->AddToWorld( dispHandle );
+			}
+		}
+	}
+
+	return( eResult );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles key values when loading a VMF file.
+// Input  : szKey - Key being handled.
+//			szValue - Value of the key in the VMF file.
+// Output : Returns ChunkFile_Ok or an error if there was a parsing error.
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CMapFace::LoadKeyCallback(const char *szKey, const char *szValue, LoadFace_t *pLoadFace)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	CMapFace *pFace = pLoadFace->pFace;
+
+	if (!stricmp(szKey, "id"))
+	{
+		CChunkFile::ReadKeyValueInt(szValue, pFace->m_nFaceID);
+	}
+	else if (!stricmp(szKey, "rotation"))
+	{
+		pFace->texture.rotate = atof(szValue);
+	}
+	else if (!stricmp(szKey, "plane"))
+	{
+		int nRead = sscanf(szValue, "(%f %f %f) (%f %f %f) (%f %f %f)", 
+			&pFace->plane.planepts[0][0], &pFace->plane.planepts[0][1], &pFace->plane.planepts[0][2],
+			&pFace->plane.planepts[1][0], &pFace->plane.planepts[1][1], &pFace->plane.planepts[1][2],
+			&pFace->plane.planepts[2][0], &pFace->plane.planepts[2][1], &pFace->plane.planepts[2][2]);
+
+		if (nRead != 9)
+		{
+			// TODO: need specific error message
+			return(ChunkFile_Fail);
+		}
+	}
+	else if (!stricmp(szKey, "material"))
+	{
+		strcpy(pLoadFace->szTexName, szValue);
+	}
+	else if (!stricmp(szKey, "uaxis"))
+	{
+		int nRead = sscanf(szValue, "[%f %f %f %f] %f",
+			&pFace->texture.UAxis[0], &pFace->texture.UAxis[1], &pFace->texture.UAxis[2], &pFace->texture.UAxis[3], &pFace->texture.scale[0]);
+
+		if (nRead != 5)
+		{
+			// TODO: need specific error message
+			return(ChunkFile_Fail);
+		}
+	}
+	else if (!stricmp(szKey, "vaxis"))
+	{
+		int nRead = sscanf(szValue, "[%f %f %f %f] %f",
+			&pFace->texture.VAxis[0], &pFace->texture.VAxis[1], &pFace->texture.VAxis[2], &pFace->texture.VAxis[3], &pFace->texture.scale[1]);
+
+		if (nRead != 5)
+		{
+			// TODO: need specific error message
+			return(ChunkFile_Fail);
+		}
+	}
+	else if (!stricmp(szKey, "lightmapscale"))
+	{
+		pFace->texture.nLightmapScale = atoi(szValue);
+	}
+	else if (!stricmp(szKey, "smoothing_groups"))
+	{
+		pFace->m_fSmoothingGroups = atoi(szValue);
+	}
+
+	return(ChunkFile_Ok);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads a face chunk from the VMF file.
+// Input  : pFile - Chunk file being loaded.
+// Output : Returns ChunkFile_Ok or an error if there was a parsing error.
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CMapFace::LoadVMF(CChunkFile *pFile)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	//
+	// Set up handlers for the subchunks that we are interested in.
+	//
+	CChunkHandlerMap Handlers;
+	Handlers.AddHandler("dispinfo", (ChunkHandler_t)LoadDispInfoCallback, this);
+
+	//
+	// Read the keys and sub-chunks.
+	//
+	LoadFace_t LoadFace;
+	memset(&LoadFace, 0, sizeof(LoadFace));
+	LoadFace.pFace = this;
+
+	pFile->PushHandlers(&Handlers);
+	ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadKeyCallback, &LoadFace);
+	pFile->PopHandlers();
+
+	if (eResult == ChunkFile_Ok)
+	{
+		CalcPlane();
+		SetTexture(LoadFace.szTexName);
+	}
+
+	return(eResult);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called after this object is added to the world.
+//
+//			NOTE: This function is NOT called during serialization. Use PostloadWorld
+//				  to do similar bookkeeping after map load.
+//
+// Input  : pWorld - The world that we have been added to.
+//-----------------------------------------------------------------------------
+void CMapFace::OnAddToWorld(CMapWorld *pWorld)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	if (HasDisp())
+	{
+		//
+		// Add it to the world displacement list.
+		//
+		IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+		if (pDispMgr != NULL)
+		{
+			pDispMgr->AddToWorld( m_DispHandle );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called just after this object has been removed from the world so
+//			that it can unlink itself from other objects in the world.
+// Input  : pWorld - The world that we were just removed from.
+//			bNotifyChildren - Whether we should forward notification to our children.
+//-----------------------------------------------------------------------------
+void CMapFace::OnRemoveFromWorld(void)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	if (HasDisp())
+	{
+		//
+		// Add it to the world displacement list.
+		//
+		IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
+		if (pDispMgr != NULL)
+		{
+			pDispMgr->RemoveFromWorld( m_DispHandle );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pFile - 
+// Output : ChunkFileResult_t
+//-----------------------------------------------------------------------------
+ChunkFileResult_t CMapFace::SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo)
+{
+	NormalizeTextureShifts();
+
+	//
+	// Check for duplicate plane points. All three plane points must be unique
+	// or it isn't a valid plane. Try to fix it if it isn't valid.
+	//
+	if (!CheckFace())
+	{
+		Fix();
+	}
+
+	ChunkFileResult_t eResult = pFile->BeginChunk("side");
+
+	char szBuf[512];
+
+	//
+	// Write our unique face ID.
+	//
+	if (eResult == ChunkFile_Ok)
+	{
+		eResult = pFile->WriteKeyValueInt("id", m_nFaceID);
+	}
+
+	//
+	// Write the plane information.
+	//
+	if (eResult == ChunkFile_Ok)
+	{
+		sprintf(szBuf, "(%g %g %g) (%g %g %g) (%g %g %g)",
+				(double)plane.planepts[0][0], (double)plane.planepts[0][1], (double)plane.planepts[0][2],
+				(double)plane.planepts[1][0], (double)plane.planepts[1][1], (double)plane.planepts[1][2],
+				(double)plane.planepts[2][0], (double)plane.planepts[2][1], (double)plane.planepts[2][2]);
+
+		eResult = pFile->WriteKeyValue("plane", szBuf);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		char szTexture[MAX_PATH];
+		strcpy(szTexture, texture.texture);
+		strupr(szTexture);
+
+		eResult = pFile->WriteKeyValue("material", szTexture);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		sprintf(szBuf, "[%g %g %g %g] %g", (double)texture.UAxis[0], (double)texture.UAxis[1], (double)texture.UAxis[2], (double)texture.UAxis[3], (double)texture.scale[0]);
+		eResult = pFile->WriteKeyValue("uaxis", szBuf);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		sprintf(szBuf, "[%g %g %g %g] %g", (double)texture.VAxis[0], (double)texture.VAxis[1], (double)texture.VAxis[2], (double)texture.VAxis[3], (double)texture.scale[1]);
+		eResult = pFile->WriteKeyValue("vaxis", szBuf);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		eResult = pFile->WriteKeyValueFloat("rotation", texture.rotate);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		eResult = pFile->WriteKeyValueFloat("lightmapscale", texture.nLightmapScale);
+	}
+
+	// Save smoothing group data.
+	if (eResult == ChunkFile_Ok)
+	{
+		eResult = pFile->WriteKeyValueInt("smoothing_groups", m_fSmoothingGroups );
+	}
+
+	//
+	// Write the displacement chunk.
+	//
+	if ((eResult == ChunkFile_Ok) && (HasDisp()))
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		eResult = pDisp->SaveVMF(pFile, pSaveInfo);
+	}
+
+	if (eResult == ChunkFile_Ok)
+	{
+		eResult = pFile->EndChunk();
+	}
+
+	return(eResult);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Enables or disables the special rendering of selected faces.
+// Input  : bShowSelection - true to enable, false to disable.
+//-----------------------------------------------------------------------------
+void CMapFace::SetShowSelection(bool bShowSelection)
+{
+	CMapFace::m_bShowFaceSelection = bShowSelection;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : nPoint - 
+//			u - 
+//			v - 
+//-----------------------------------------------------------------------------
+void CMapFace::SetTextureCoords(int nPoint, float u, float v)
+{
+	if (nPoint < nPoints)
+	{
+		m_pTextureCoords[nPoint][0] = u;
+		m_pTextureCoords[nPoint][1] = v;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+size_t CMapFace::GetDataSize( void )
+{
+	// get base map class size
+	size_t size = sizeof( CMapFace );
+	
+	//
+	// better approximate by added in verts, texture coordinates, 
+	// and lightmap coordinates
+	//
+	size += ( sizeof( Vector ) * nPoints );
+	size += ( sizeof( Vector2D ) * ( nPoints * 2 ) );
+
+	// add displacement size if necessary
+	if( HasDisp() )
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		size += pDisp->GetSize();
+	}
+
+	return size;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns our bounds for 2D rendering. These bounds do not consider
+//			any displacement information.
+// Input  : boundMin - 
+//			boundMax - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CMapFace::GetRender2DBox( Vector& boundMin, Vector& boundMax )
+{
+	// valid face?
+	if( nPoints == 0 )
+		return false;
+
+	//
+	// find min and maximum points on face
+	//
+	VectorFill( boundMin, COORD_NOTINIT );
+	VectorFill( boundMax, -COORD_NOTINIT );
+	for( int i = 0; i < nPoints; i++ )
+	{
+		if( Points[i][0] < boundMin[0] ) { boundMin[0] = Points[i][0]; }
+		if( Points[i][1] < boundMin[1] ) { boundMin[1] = Points[i][1]; }
+		if( Points[i][2] < boundMin[2] ) { boundMin[2] = Points[i][2]; }
+
+		if( Points[i][0] > boundMax[0] ) { boundMax[0] = Points[i][0]; }
+		if( Points[i][1] > boundMax[1] ) { boundMax[1] = Points[i][1]; }
+		if( Points[i][2] > boundMax[2] ) { boundMax[2] = Points[i][2]; }
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns our bounds for frustum culling, including the bounds of
+//			any displacement information.
+// Input  : boundMin - 
+//			boundMax - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CMapFace::GetCullBox( Vector& boundMin, Vector& boundMax )
+{
+	// get the face bounds
+	if( !GetRender2DBox( boundMin, boundMax ) )
+		return false;
+
+	//
+	// add displacement to bounds
+	//
+	if( HasDisp() )
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+
+		Vector bbox[2];
+		pDisp->GetBoundingBox( bbox[0], bbox[1] );
+
+		for( int i = 0; i < 2; i++ )
+		{
+			if( bbox[i][0] < boundMin[0] ) { boundMin[0] = bbox[i][0]; }
+			if( bbox[i][1] < boundMin[1] ) { boundMin[1] = bbox[i][1]; }
+			if( bbox[i][2] < boundMin[2] ) { boundMin[2] = bbox[i][2]; }
+			
+			if( bbox[i][0] > boundMax[0] ) { boundMax[0] = bbox[i][0]; }
+			if( bbox[i][1] > boundMax[1] ) { boundMax[1] = bbox[i][1]; }
+			if( bbox[i][2] > boundMax[2] ) { boundMax[2] = bbox[i][2]; }
+		}
+	}
+
+	return true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : HitPos - 
+//			Start - 
+//			End - 
+// Output : Returns true if the ray intersected the face, false if not.
+//-----------------------------------------------------------------------------
+bool CMapFace::TraceLine(Vector &HitPos, Vector &HitNormal, Vector const &Start, Vector const &End )
+{
+	if (HasDisp())
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		return( pDisp->TraceLine( HitPos, HitNormal, Start, End ) );
+	}
+
+	//
+	// Find the point of intersection of the ray with the given plane.
+	//
+	float t = Start.Dot(plane.normal) - plane.dist;
+	t = t / -(End - Start).Dot(plane.normal);
+	
+	HitPos = Start + (t * (End - Start));
+	HitNormal = plane.normal;
+	return(true);
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CMapFace::TraceLineInside( Vector &HitPos, Vector &HitNormal, 
+							    Vector const &Start, Vector const &End, bool bNoDisp )
+{
+	// if the face is displaced -- collide with that
+	if( HasDisp() && !bNoDisp )
+	{
+		CMapDisp *pDisp = EditDispMgr()->GetDisp( m_DispHandle );
+		return( pDisp->TraceLine( HitPos, HitNormal, Start, End ) );
+	}
+
+	//
+	// Find the point of intersection of the ray with the given plane.
+	//
+	float t = Start.Dot( plane.normal ) - plane.dist;
+	if ( -( End - Start ).Dot( plane.normal ) != 0.0f )
+	{
+		t = t / -( End - Start ).Dot( plane.normal );	
+	}
+	HitPos = Start + ( t * ( End - Start ) );
+
+	//
+	// determine if the plane point lies behind all of the polygon planes (edges)
+	//
+	for( int ndxEdge = 0; ndxEdge < nPoints; ndxEdge++ )
+	{
+		// create the edge and cross it with the face plane normal
+		Vector edge;
+		edge = Points[(ndxEdge+1)%nPoints] - Points[ndxEdge];
+
+		PLANE edgePlane;
+		edgePlane.normal = edge.Cross( plane.normal );
+		VectorNormalize( edgePlane.normal );
+		edgePlane.dist = edgePlane.normal.Dot( Points[ndxEdge] );
+
+		// determine if the facing is correct
+		float dist = edgePlane.normal.Dot( Points[(ndxEdge+2)%nPoints] ) - edgePlane.dist;
+		if( dist > 0.0f )
+		{
+			// flip
+			edgePlane.normal.Negate();
+			edgePlane.dist = -edgePlane.dist;
+		}
+		
+		// check to see if plane point lives behind the plane
+		dist = edgePlane.normal.Dot( HitPos ) - edgePlane.dist;
+		if( dist > 0.0f )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// NOTE: actually this could be calculated once for the face since only the
+//       face normal is being used (no smoothing groups, etc.), but that may 
+//       change????
+//-----------------------------------------------------------------------------
+void CMapFace::CalcTangentSpaceAxes( void )
+{
+	// destroy old axes if need be
+	FreeTangentSpaceAxes();
+
+	// allocate memory for tangent space axes
+	if( !AllocTangentSpaceAxes( nPoints ) )
+		return;
+
+	//
+	// get the texture space axes
+	//
+	Vector4D& uVect = texture.UAxis;
+	Vector4D& vVect = texture.VAxis;
+
+	//
+	// calculate the tangent space per polygon point
+	//
+
+	for( int ptIndex = 0; ptIndex < nPoints; ptIndex++ )
+	{
+		// get the current tangent space axes
+		TangentSpaceAxes_t *pAxis = &m_pTangentAxes[ptIndex];
+
+		//
+		// create the axes
+		//
+		pAxis->binormal = vVect.AsVector3D();
+		VectorNormalize( pAxis->binormal );
+		CrossProduct( plane.normal, pAxis->binormal, pAxis->tangent );
+		VectorNormalize( pAxis->tangent );
+		CrossProduct( pAxis->tangent, plane.normal, pAxis->binormal );
+		VectorNormalize( pAxis->binormal );
+
+		//
+		// adjust tangent for "backwards" mapping if need be
+		//
+		Vector tmpVect;
+		CrossProduct( uVect.AsVector3D(), vVect.AsVector3D(), tmpVect );
+		if( DotProduct( plane.normal, tmpVect ) > 0.0f )
+		{
+			VectorScale( pAxis->tangent, -1.0f, pAxis->tangent );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CMapFace::AllocTangentSpaceAxes( int count )
+{
+	if( count < 1 )
+		return false;
+
+	m_pTangentAxes = new TangentSpaceAxes_t[count];
+	if( !m_pTangentAxes )
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapFace::FreeTangentSpaceAxes( void )
+{
+	if( m_pTangentAxes )
+	{
+		delete [] m_pTangentAxes;
+		m_pTangentAxes = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CMapFace::SmoothingGroupCount( void )
+{
+	int nCount = 0;
+	for ( int iGroup = 0; iGroup < SMOOTHING_GROUP_MAX_COUNT; ++iGroup )
+	{
+		if ( ( m_fSmoothingGroups & ( 1 << iGroup ) ) != 0 )
+		{
+			nCount++;
+		}
+	}
+
+	return nCount;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapFace::AddSmoothingGroup( int iGroup )
+{
+	Assert( iGroup >= 0 );
+	Assert( iGroup < SMOOTHING_GROUP_MAX_COUNT );
+
+	m_fSmoothingGroups |= ( 1 << ( iGroup - 1 ) );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapFace::RemoveSmoothingGroup( int iGroup )
+{
+	Assert( iGroup >= 0 );
+	Assert( iGroup < SMOOTHING_GROUP_MAX_COUNT );
+
+	m_fSmoothingGroups &= ~( 1 << ( iGroup - 1 ) );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CMapFace::InSmoothingGroup( int iGroup )
+{
+	if ( ( m_fSmoothingGroups & ( 1 << ( iGroup - 1 ) ) ) != 0 )
+		return true;
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Performs an intersection of this list with another.
+// Input  : IntersectWith - the list to intersect with.
+//			In - the list of items that were in both lists
+//			Out - the list of items that were in one list but not the other.
+//-----------------------------------------------------------------------------
+void CMapFaceList::Intersect(CMapFaceList &IntersectWith, CMapFaceList &In, CMapFaceList &Out)
+{
+	//
+	// See what we items have that are in the other list.
+	//
+	for (int i = 0; i < Count(); i++)
+	{
+		CMapFace *pFace = Element(i);
+
+		if (IntersectWith.Find(pFace) != -1)
+		{
+			if (In.Find(pFace) == -1)
+			{
+				In.AddToTail(pFace);
+			}
+		}
+		else
+		{
+			if (Out.Find(pFace) == -1)
+			{
+				Out.AddToTail(pFace);
+			}
+		}
+	}
+
+	//
+	// Now go the other way.
+	//
+	for (int i = 0; i < IntersectWith.Count(); i++)
+	{
+		CMapFace *pFace = IntersectWith.Element(i);
+
+		if (Find(pFace) != -1)
+		{
+			if (In.Find(pFace) == -1)
+			{
+				In.AddToTail(pFace);
+			}
+		}
+		else
+		{
+			if (Out.Find(pFace) == -1)
+			{
+				Out.AddToTail(pFace);
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Performs an intersection of this list with another.
+// Input  : IntersectWith - the list to intersect with.
+//			In - the list of items that were in both lists
+//			Out - the list of items that were in one list but not the other.
+//-----------------------------------------------------------------------------
+void CMapFaceIDList::Intersect(CMapFaceIDList &IntersectWith, CMapFaceIDList &In, CMapFaceIDList &Out)
+{
+	//
+	// See what we items have that are in the other list.
+	//
+	for (int i = 0; i < Count(); i++)
+	{
+		int nFaceID = Element(i);
+		if (IntersectWith.Find(nFaceID) != -1)
+		{
+			if (In.Find(nFaceID) == -1)
+			{
+				In.AddToTail(nFaceID);
+			}
+		}
+		else
+		{
+			if (Out.Find(nFaceID) == -1)
+			{
+				Out.AddToTail(nFaceID);
+			}
+		}
+	}
+
+	//
+	// Now go the other way.
+	//
+	for (int i = 0; i < IntersectWith.Count(); i++)
+	{
+		int nFaceID = IntersectWith.Element(i);
+
+		if (Find(nFaceID) != -1)
+		{
+			if (In.Find(nFaceID) == -1)
+			{
+				In.AddToTail(nFaceID);
+			}
+		}
+		else
+		{
+			if (Out.Find(nFaceID) == -1)
+			{
+				Out.AddToTail(nFaceID);
+			}
+		}
+	}
+}
+
+void CMapFace::DoTransform(const VMatrix &matrix)
+{
+	SignalUpdate( EVTYPE_FACE_CHANGED );
+	if( nPoints < 3 )
+	{
+		Assert( nPoints > 2 );
+		return;
+	}
+
+	CMapDisp *pDisp = NULL;
+	Vector bbDispOld[2]; // Old bbox for the disp.
+	if( HasDisp() )
+	{
+		EditDispHandle_t handle = GetDisp();
+		pDisp = EditDispMgr()->GetDisp( handle );
+		if ( pDisp )
+			pDisp->GetBoundingBox( bbDispOld[0], bbDispOld[1] );
+	}
+
+	Vector oldPoint = Points[0];
+	
+	// Transform the face points.
+	for (int i = 0; i < nPoints; i++)
+	{
+		TransformPoint( matrix, Points[i] );
+	}
+
+	bool bFlip = (matrix[0][0]*matrix[1][1]*matrix[2][2]) < 0;
+
+	if ( bFlip )
+	{
+		// mirror transformation would break CCW culling, so revert point order
+		PointsRevertOrder( Points, nPoints );
+	}
+
+	CalcPlaneFromFacePoints();
+
+	// ok, now apply all changes to texture & displacment too
+	VMatrix mTrans = matrix;
+
+	QAngle rotateAngles;
+	Vector moveDelta;
+	MatrixAngles( matrix.As3x4(), rotateAngles, moveDelta );
+
+	bool bIsLocking = Options.IsLockingTextures()!=0;
+	bool bIsMoving = moveDelta.LengthSqr() > 0.00001;
+
+	// erase move component from matrix
+	mTrans.SetTranslation( vec3_origin );
+
+	// check if new matrix is simple identity matrix
+	if ( mTrans.IsIdentity() )
+	{
+		if ( GetTexture() )
+		{
+			if ( bIsMoving && bIsLocking )
+			{
+				// Offset texture coordinates if we're moving and texture locking.
+				OffsetTexture(moveDelta);
+			}
+
+			// Recalculate the texture coordinates for this face.
+			CalcTextureCoords();
+
+		}
+
+		if ( pDisp )
+		{
+			pDisp->UpdateSurfData( this );
+			
+			// Update the neighbors of displacements that intersect the old as well as the new bbox.
+			// Without this, there can be errors if you drag > 2 edges to interset each other, then
+			// move one of the intersectors (cloning can easily cause this case to happen).
+			Vector bbDispNew[2];
+			pDisp->GetBoundingBox( bbDispNew[0], bbDispNew[1] );
+			
+			CMapDisp::UpdateNeighborsOfDispsIntersectingBox( bbDispOld[0], bbDispOld[1], 1.0 );
+			CMapDisp::UpdateNeighborsOfDispsIntersectingBox( bbDispNew[0], bbDispNew[1], 1.0 );
+		}
+
+		// Create any detail objects if appropriate
+		DetailObjects::BuildAnyDetailObjects(this);
+
+		return;
+	}
+
+	// ok, transformation is more complex then a simple move
+
+	if ( GetTexture() )
+	{
+		Vector vU = texture.UAxis.AsVector3D();
+		Vector vV = texture.VAxis.AsVector3D();
+
+		// store original length
+		float fScaleU = vU.Length();
+		float fScaleV = vV.Length();
+
+		if ( fScaleU <= 0 )
+			fScaleU = 1;
+
+		if ( fScaleV <=0 )
+			fScaleV = 1;
+
+		// transform UV axis
+		TransformPoint( mTrans, vU );
+		TransformPoint( mTrans, vV );
+
+		// get scaling factor for both axes
+		fScaleU = vU.Length()/fScaleU;
+		fScaleV = vV.Length()/fScaleV;
+
+		if ( fScaleU <= 0 )
+			fScaleU = 1;
+
+		if ( fScaleV <=0 )
+			fScaleV = 1;
+
+		// check is the transformation would destory the UV axis (both normals & perpendicular)
+		bool bUVAxisSameScale = fequal(fScaleV,1,0.0001) && fequal(fScaleU,1,0.0001);
+		bool bUVAxisPerpendicular = fequal(DotProduct( vU, vV ),0,0.0025);
+
+		// Rotate the U/V axes to keep them oriented the same relative
+		// to this face.
+
+		if ( bIsLocking && bUVAxisPerpendicular )
+		{
+			// make sure UV axes are normals & perpendicalur
+			texture.UAxis.AsVector3D() = vU/fScaleU;
+			texture.VAxis.AsVector3D() = vV/fScaleV;
+		}
+
+		if ( bUVAxisSameScale )
+		{
+			// scale is fine
+			if ( !bIsLocking )
+			{
+				// If we are not texture locking, recalculate the texture axes based on current
+				// texture alignment setting. This prevents the axes from becoming normal to the face.
+				InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_AXES | INIT_TEXTURE_FORCE);
+			}
+		}
+		else // we stretch/scale axes 
+		{
+			// operation changes scale of textures, check if we really want that:
+			bIsLocking = Options.IsScaleLockingTextures()!=0;
+
+			if ( bIsLocking )
+			{
+				texture.scale[0] *= fScaleU;
+				texture.scale[1] *= fScaleV;
+			}
+		}
+		
+		if ( bIsMoving && bIsLocking )
+		{
+			// Offset texture coordinates if we're moving and texture locking.
+			OffsetTexture(moveDelta);
+		}
+
+		// Recalculate the texture coordinates for this face.
+		CalcTextureCoords();
+	}
+
+	// rotate the displacement field data - if any!
+	if( pDisp )
+	{
+ 		pDisp->DoTransform( mTrans );
+
+		// Update the neighbors of displacements that intersect the old as well as the new bbox.
+		// Without this, there can be errors if you drag > 2 edges to interset each other, then
+		// move one of the intersectors (cloning can easily cause this case to happen).
+		Vector bbDispNew[2];
+		pDisp->GetBoundingBox( bbDispNew[0], bbDispNew[1] );
+		
+		CMapDisp::UpdateNeighborsOfDispsIntersectingBox( bbDispOld[0], bbDispOld[1], 1.0 );
+		CMapDisp::UpdateNeighborsOfDispsIntersectingBox( bbDispNew[0], bbDispNew[1], 1.0 );
+	}
+	// Create any detail objects if appropriate
+	DetailObjects::BuildAnyDetailObjects(this);
+}
+