csgo/cstrike15_src/hammer/mapoverlay.cpp

//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include <stdafx.h>
#include "MapOverlay.h"
#include "MapFace.h"
#include "MapSolid.h"
#include "MapWorld.h"
#include "MainFrm.h"
#include "GlobalFunctions.h"
#include "MapDoc.h"
#include "TextureSystem.h"
#include "Material.h"
#include "materialsystem/IMesh.h"
#include "Box3D.h"
#include "MapDefs.h"
#include "CollisionUtils.h"
#include "MapSideList.h"
#include "MapDisp.h"
#include "ToolManager.h"
#include "objectproperties.h"
#include "ChunkFile.h"
#include "mapview.h"
#include "options.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

IMPLEMENT_MAPCLASS( CMapOverlay )

#define OVERLAY_INITSIZE				25.0f		// x2

#define OVERLAY_BASIS_U					0
#define OVERLAY_BASIS_V					1
#define OVERLAY_BASIS_NORMAL			2	

#define OVERLAY_HANDLES_COUNT			4

#define OVERLAY_WORLDSPACE_EPSILON		0.03125f
#define OVERLAY_DISPSPACE_EPSILON		0.000001f
#define OVERLAY_BARYCENTRIC_EPSILON		0.001f

#define OVERLAY_BLENDTYPE_VERT			0
#define OVERLAY_BLENDTYPE_EDGE			1
#define OVERLAY_BLENDTYPE_BARY			2
#define OVERLAY_ANGLE0					1
#define OVERLAY_ANGLE45					2
#define OVERLAY_ANGLE90					3
#define OVERLAY_ANGLE135				4

#define OVERLAY_INVALID_VALUE			-99999.9f

//=============================================================================
//
// Basis Functions
//

//-----------------------------------------------------------------------------
// Purpose: Initialize the basis data.
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_Clear( void )
{
	m_Basis.m_pFace = NULL;
	m_Basis.m_vecOrigin.Init();

	for( int iAxis = 0; iAxis < 3; iAxis++ )
	{
		m_Basis.m_vecAxes[iAxis].Init( OVERLAY_INVALID_VALUE, OVERLAY_INVALID_VALUE, OVERLAY_INVALID_VALUE );
		m_Basis.m_nAxesFlip[iAxis] = 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Build the overlay basis given an entity and base face (CMapFace).
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_Init( CMapFace *pFace )
{
	// Valid face?
	Assert( pFace != NULL );
	if( !pFace )
		return;

	// Set the face the basis are derived from.
	Basis_SetFace( pFace );

	// Set the basis origin.
	Basis_UpdateOrigin();

	// Setup the basis axes.
	Basis_BuildAxes();

	// Initialize the texture coordinates - based on basis.
	Material_TexCoordInit();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_UpdateOrigin( void )
{
	CMapEntity *pEntity = static_cast<CMapEntity*>( GetParent() );
	if ( pEntity )
	{
		Vector vecEntityOrigin;
		pEntity->GetOrigin( vecEntityOrigin );

		Vector vecPoint( 0.0f, 0.0f, 0.0f );
		if ( !EntityOnSurfFromListToBaseFacePlane( vecEntityOrigin, vecPoint ) )
		{
			vecPoint = vecEntityOrigin;
		}

		m_Basis.m_vecOrigin = vecPoint;
	}

	// Update the property box.
	Basis_UpdateParentKey();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_BuildAxes( void )
{
	// Valid face?
	if( !m_Basis.m_pFace )
		return;

	// Build the basis axes.
	Vector vecFaceNormal;
	m_Basis.m_pFace->GetFaceNormal( vecFaceNormal );
	VectorNormalize( vecFaceNormal );
	VectorCopy( vecFaceNormal, m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] );

	Basis_SetInitialUAxis( vecFaceNormal );

	m_Basis.m_vecAxes[OVERLAY_BASIS_V] = m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].Cross( m_Basis.m_vecAxes[OVERLAY_BASIS_U] );
	VectorNormalize( m_Basis.m_vecAxes[OVERLAY_BASIS_V] );

	m_Basis.m_vecAxes[OVERLAY_BASIS_U] = m_Basis.m_vecAxes[OVERLAY_BASIS_V].Cross( m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] );
	VectorNormalize( m_Basis.m_vecAxes[OVERLAY_BASIS_U] );

	// Flip uvn axes?
	for ( int iAxis = 0; iAxis < 3; ++iAxis )
	{
		for ( int iComp = 0; iComp < 3; ++iComp )
		{
			if ( Basis_IsFlipped( iAxis, iComp ) )
			{
				m_Basis.m_vecAxes[iAxis][iComp] = -m_Basis.m_vecAxes[iAxis][iComp];
			}
		}
	}

	Basis_UpdateParentKey();
}

//-----------------------------------------------------------------------------
// Purpose: A basis building helper function that finds the best guess u-axis
//          given a base face (CMapFace) normal.
//   Input: vecNormal - the base face normal
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_SetInitialUAxis( Vector const &vecNormal )
{
	// Find the major vector component.
	int nMajorAxis = 0;
	float flAxisValue = vecNormal[0];
	if ( FloatMakePositive( vecNormal[1] ) > FloatMakePositive( flAxisValue ) ) 
	{ 
		nMajorAxis = 1; 
		flAxisValue = vecNormal[1]; 
	}
	if ( FloatMakePositive( vecNormal[2] ) > FloatMakePositive( flAxisValue ) ) 
	{ 
		nMajorAxis = 2; 
	}

	if ( ( nMajorAxis == 1 ) || ( nMajorAxis == 2 ) )
	{
		m_Basis.m_vecAxes[OVERLAY_BASIS_U].Init( 1.0f, 0.0f, 0.0f );
	}
	else
	{
		m_Basis.m_vecAxes[OVERLAY_BASIS_U].Init( 0.0f, 1.0f, 0.0f );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMapOverlay::Basis_IsValid( void )
{
	for ( int iBasis = 0; iBasis < 3; ++iBasis )
	{
		for ( int iAxis = 0; iAxis < 3; ++iAxis )
		{
			if ( m_Basis.m_vecAxes[iBasis][iAxis] == OVERLAY_INVALID_VALUE )
				return false;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_SetFace( CMapFace *pFace )
{
	// Verify face.
	if ( !pFace )
		return;

	m_Basis.m_pFace = pFace;
}

//-----------------------------------------------------------------------------
// Purpose: Copy the basis data from the source into the destination.
//   Input: pSrc - the basis source data
//          pDst (Output) - destination for the  basis data
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_Copy( Basis_t *pSrc, Basis_t *pDst )
{
	pDst->m_pFace = pSrc->m_pFace;
	pDst->m_vecOrigin = pSrc->m_vecOrigin;

	for ( int iAxis = 0; iAxis < 3; iAxis++ )
	{
		pDst->m_vecAxes[iAxis] = pSrc->m_vecAxes[iAxis];
		pDst->m_nAxesFlip[iAxis] = pSrc->m_nAxesFlip[iAxis];
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_UpdateParentKey( void )
{
	char szValue[80];

	CMapEntity *pEntity = ( CMapEntity* )GetParent();
	if ( pEntity )
	{
		sprintf( szValue, "%g %g %g", m_Basis.m_vecOrigin.x, m_Basis.m_vecOrigin.y, m_Basis.m_vecOrigin.z );
		pEntity->NotifyChildKeyChanged( this, "BasisOrigin", szValue );

		sprintf( szValue, "%g %g %g", m_Basis.m_vecAxes[OVERLAY_BASIS_U].x, m_Basis.m_vecAxes[OVERLAY_BASIS_U].y, m_Basis.m_vecAxes[OVERLAY_BASIS_U].z );
		pEntity->NotifyChildKeyChanged( this, "BasisU", szValue );

		sprintf( szValue, "%g %g %g", m_Basis.m_vecAxes[OVERLAY_BASIS_V].x, m_Basis.m_vecAxes[OVERLAY_BASIS_V].y, m_Basis.m_vecAxes[OVERLAY_BASIS_V].z );
		pEntity->NotifyChildKeyChanged( this, "BasisV", szValue );

		sprintf( szValue, "%g %g %g", m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].x, m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].y, m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].z );
		pEntity->NotifyChildKeyChanged( this, "BasisNormal", szValue );
	}
}

//=============================================================================
//
// Basis - Legacy support!
//

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_BuildFromSideList( void )
{
	// Initialization (don't have or couldn't find the basis face)
	if ( m_Faces.Count() > 0 )
	{
		Basis_Init( m_Faces.Element( 0 ) );
	}
	else
	{
		m_Basis.m_pFace = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//   Input: iAxis - 0, 1, 2 (u, v, n)
//          iComponet - 0, 1, 2 (x, y, z)
//-----------------------------------------------------------------------------
void CMapOverlay::Basis_ToggleAxesFlip( int iAxis, int iComponent )
{
	if ( iAxis < 0 || iAxis > 2 || iComponent < 0 || iComponent > 2 )
		return;

	int nValue = ( 1 << iComponent );
	m_Basis.m_nAxesFlip[iAxis] ^= nValue;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMapOverlay::Basis_IsFlipped( int iAxis, int iComponent )
{
	if ( iAxis < 0 || iAxis > 2 || iComponent < 0 || iComponent > 2 )
		return false;
	
	int nValue = ( 1 << iComponent );
	return ( ( m_Basis.m_nAxesFlip[iAxis] & nValue ) != 0 );
}

//=============================================================================
//
// Handles Functions
//

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_Clear( void )
{
	m_Handles.m_iHit = -1;

	for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; iHandle++ )
	{
		m_Handles.m_vec3D[iHandle].Init();
	}

	m_Handles.m_vecBasisCoords[0].Init( -OVERLAY_INITSIZE, -OVERLAY_INITSIZE );
	m_Handles.m_vecBasisCoords[1].Init( -OVERLAY_INITSIZE, OVERLAY_INITSIZE );
	m_Handles.m_vecBasisCoords[2].Init( OVERLAY_INITSIZE, OVERLAY_INITSIZE );
	m_Handles.m_vecBasisCoords[3].Init( OVERLAY_INITSIZE, -OVERLAY_INITSIZE );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_Init( CMapFace *pFace )
{
	IEditorTexture *pTexture = g_Textures.FindActiveTexture( GetDefaultTextureName() );
	int nWidth = pTexture->GetMappingWidth();
	int nHeight = pTexture->GetMappingHeight();

	// Half-height (width) and 1/4 scale
	int nWidthHalf = nWidth / 8;
	int nHeightHalf = nHeight / 8;

	m_Handles.m_vecBasisCoords[0].Init( -nWidthHalf, -nHeightHalf );
	m_Handles.m_vecBasisCoords[1].Init( -nWidthHalf, nHeightHalf );
	m_Handles.m_vecBasisCoords[2].Init( nWidthHalf, nHeightHalf );
	m_Handles.m_vecBasisCoords[3].Init( nWidthHalf, -nHeightHalf );

	Handles_Build3D();

	Handles_UpdateParentKey();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_Build3D( void )
{
	// Verify that we have a valid basis to build the handles from.
	if ( !Basis_IsValid() )
		return;

	for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; iHandle++ )
	{
		Vector vecHandle;
		OverlayUVToOverlayPlane( m_Handles.m_vecBasisCoords[iHandle], vecHandle );
		OverlayPlaneToSurfFromList( vecHandle, m_Handles.m_vec3D[iHandle] );
	}

	Handles_FixOrder();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_Render3D( CRender3D *pRender )
{
	// Set the render mode to "flat."
	pRender->PushRenderMode( RENDER_MODE_FLAT );

	// Set the color, should be based on selection.
	unsigned char ucColor[4];
	ucColor[0] = ucColor[1] = ucColor[2] = ucColor[3] = 255;

	unsigned char ucSelectColor[4];
	ucSelectColor[0] = ucSelectColor[3] = 255;
	ucSelectColor[1] = ucSelectColor[2] = 0;

	pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );

	for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; iHandle++ )
	{
		pRender->BeginRenderHitTarget( this, iHandle );
		if ( m_Handles.m_iHit == iHandle )
		{
			pRender->SetHandleColor( ucSelectColor[0], ucSelectColor[1], ucSelectColor[2] );
		}
		else
		{
			pRender->SetHandleColor( ucColor[0], ucColor[1], ucColor[2] );
		}

		pRender->DrawHandle( m_Handles.m_vec3D[iHandle] );

		pRender->EndRenderHitTarget();
	}

	pRender->PopRenderMode();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_SurfToOverlayPlane( CMapFace *pFace, Vector const &vecSurf, Vector &vecPoint )
{
	Vector vecWorld;
	if ( pFace->HasDisp() )
	{
		EditDispHandle_t handle = pFace->GetDisp();
		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
		pDisp->SurfToBaseFacePlane( vecSurf, vecWorld );
	}
	else
	{
		vecWorld = vecSurf;
	}

	WorldToOverlayPlane( vecWorld, vecPoint );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_Copy( Handles_t *pSrc, Handles_t *pDst )
{
	pDst->m_iHit = pSrc->m_iHit;

	for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; ++iHandle )
	{
		pDst->m_vecBasisCoords[iHandle] = pSrc->m_vecBasisCoords[iHandle];
		pDst->m_vec3D[iHandle] = pSrc->m_vec3D[iHandle];
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Handles_UpdateParentKey( void )
{
	char szValue[80];

	CMapEntity *pEntity = ( CMapEntity* )GetParent();
	if ( pEntity )
	{
		sprintf( szValue, "%g %g %g", m_Handles.m_vecBasisCoords[0].x, m_Handles.m_vecBasisCoords[0].y, ( float )m_Basis.m_nAxesFlip[0] );
		pEntity->NotifyChildKeyChanged( this, "uv0", szValue );

		sprintf( szValue, "%g %g %g", m_Handles.m_vecBasisCoords[1].x, m_Handles.m_vecBasisCoords[1].y, ( float )m_Basis.m_nAxesFlip[1] );
		pEntity->NotifyChildKeyChanged( this, "uv1", szValue );

		sprintf( szValue, "%g %g %g", m_Handles.m_vecBasisCoords[2].x, m_Handles.m_vecBasisCoords[2].y, ( float )m_Basis.m_nAxesFlip[2] );
		pEntity->NotifyChildKeyChanged( this, "uv2", szValue );

		sprintf( szValue, "%g %g %g", m_Handles.m_vecBasisCoords[3].x, m_Handles.m_vecBasisCoords[3].y, 0.0f );
		pEntity->NotifyChildKeyChanged( this, "uv3", szValue );
	}
}

//=============================================================================
//
// ClipFace Functions
//

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CMapOverlay::ClipFace_t *CMapOverlay::ClipFace_Create( int nSize )
{
	ClipFace_t *pClipFace = new ClipFace_t;
	if ( pClipFace )
	{
		pClipFace->m_nPointCount = nSize;
		if ( nSize > 0 )
		{
			pClipFace->m_aPoints.SetSize( nSize );
			pClipFace->m_aNormals.SetSize( nSize );
			pClipFace->m_aDispPointUVs.SetSize( nSize );
			
			for ( int iCoord = 0; iCoord < NUM_CLIPFACE_TEXCOORDS; iCoord++ )
			{
				pClipFace->m_aTexCoords[iCoord].SetSize( nSize );
			}

			pClipFace->m_aBlends.SetSize( nSize );
			
			for ( int iPoint = 0; iPoint < nSize; iPoint++ )
			{
				pClipFace->m_aPoints[iPoint].Init();
				pClipFace->m_aNormals[iPoint].Init( 0, 0, 1 );
				pClipFace->m_aDispPointUVs[iPoint].Init();
				pClipFace->m_aBlends[iPoint].Init();
				
				for ( int iCoord = 0; iCoord < NUM_CLIPFACE_TEXCOORDS; iCoord++ )
				{
					pClipFace->m_aTexCoords[iCoord][iPoint].Init();
				}
			}
		}
	}

	return pClipFace;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_Destroy( ClipFace_t **ppClipFace )
{
	if( *ppClipFace )
	{
		delete *ppClipFace;
		*ppClipFace = NULL;
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CMapOverlay::ClipFace_t *CMapOverlay::ClipFace_Copy( ClipFace_t *pSrc )
{
	ClipFace_t *pDst = ClipFace_Create( pSrc->m_nPointCount );
	if ( pDst )
	{
		for ( int iPoint = 0; iPoint < pSrc->m_nPointCount; iPoint++ )
		{
			pDst->m_aPoints[iPoint] = pSrc->m_aPoints[iPoint];
			pDst->m_aNormals[iPoint] = pSrc->m_aNormals[iPoint];
			pDst->m_aDispPointUVs[iPoint] = pSrc->m_aDispPointUVs[iPoint];
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
			{
				pDst->m_aTexCoords[iTexCoord][iPoint] = pSrc->m_aTexCoords[iTexCoord][iPoint];
			}

			pDst->m_aBlends[iPoint].m_nType = pSrc->m_aBlends[iPoint].m_nType;
			for ( int iBlend = 0; iBlend < 3; iBlend++ )
			{
				pDst->m_aBlends[iPoint].m_iPoints[iBlend] = pSrc->m_aBlends[iPoint].m_iPoints[iBlend];
				pDst->m_aBlends[iPoint].m_flBlends[iBlend] = pSrc->m_aBlends[iPoint].m_flBlends[iBlend];
			}
		}
	}

	return pDst;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_GetBounds( ClipFace_t *pClipFace, Vector &vecMin, Vector &vecMax )
{
	if ( pClipFace )
	{
		vecMin = vecMax = pClipFace->m_aPoints.Element( 0 );
		
		for ( int iPoints = 1; iPoints < pClipFace->m_nPointCount; iPoints++ )
		{
			Vector vecPoint = pClipFace->m_aPoints.Element( iPoints );
			
			// Min
			if ( vecMin.x > vecPoint.x ) { vecMin.x = vecPoint.x; }
			if ( vecMin.y > vecPoint.y ) { vecMin.y = vecPoint.y; }
			if ( vecMin.z > vecPoint.z ) { vecMin.z = vecPoint.z; }
			
			// Max
			if ( vecMax.x < vecPoint.x ) { vecMax.x = vecPoint.x; }
			if ( vecMax.y < vecPoint.y ) { vecMax.y = vecPoint.y; }
			if ( vecMax.z < vecPoint.z ) { vecMax.z = vecPoint.z; }
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_Clip( ClipFace_t *pClipFace, cplane_t *pClipPlane, float flEpsilon,
							     ClipFace_t **ppFront, ClipFace_t **ppBack )
{
	if ( !pClipFace )
		return;

	float flDists[128];
	int	nSides[128];
	int nSideCounts[3];

	// Initialize
	*ppFront = *ppBack = NULL;

	// Determine "sidedness" of all the polygon points.
	nSideCounts[0] = nSideCounts[1] = nSideCounts[2] = 0;
	int iPoint;
	for ( iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
	{
		flDists[iPoint] = pClipPlane->normal.Dot( pClipFace->m_aPoints.Element( iPoint ) ) - pClipPlane->dist;

		if ( flDists[iPoint] > flEpsilon )
		{
			nSides[iPoint] = SIDE_FRONT;
		}
		else if ( flDists[iPoint] < -flEpsilon )
		{
			nSides[iPoint] = SIDE_BACK;
		}
		else
		{
			nSides[iPoint] = SIDE_ON;
		}

		nSideCounts[nSides[iPoint]]++;
	}

	// Wrap around (close the polygon).
	nSides[iPoint] = nSides[0];
	flDists[iPoint] =  flDists[0];

	// All points in back - no split (copy face to back).
	if( !nSideCounts[SIDE_FRONT] )
	{
		*ppBack = ClipFace_Copy( pClipFace );
		return;
	}

	// All points in front - no split (copy face to front).
	if( !nSideCounts[SIDE_BACK] )
	{
		*ppFront = ClipFace_Copy( pClipFace );
		return;
	}

	// Build new front and back faces. Leave room for two extra points on each side because any
	// point might be on the plane, which would put it into both the front and back sides, and then
	// we need to allow for an additional vertex created by clipping.
	ClipFace_t *pFront = ClipFace_Create( pClipFace->m_nPointCount + 2 );
	ClipFace_t *pBack = ClipFace_Create( pClipFace->m_nPointCount + 2 );
	if ( !pFront || !pBack )
	{
		ClipFace_Destroy( &pFront );
		ClipFace_Destroy( &pBack );
		return;
	}

	// Reset the counts as they are used to build the surface.
	pFront->m_nPointCount = 0;
	pBack->m_nPointCount = 0;

	// For every point on the face being clipped, determine which side of the clipping plane it is on
	// and add it to a either a front list or a back list. Points that are on the plane are added to
	// both lists.
	for ( iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
	{
		// "On" clip plane.
		if ( nSides[iPoint] == SIDE_ON )
		{
			pFront->m_aPoints[pFront->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pFront->m_aNormals[pFront->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			pFront->m_nPointCount++;

			pBack->m_aPoints[pBack->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pBack->m_aNormals[pBack->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			pBack->m_nPointCount++;

			continue;
		}

		// "In back" of clip plane.
		if ( nSides[iPoint] == SIDE_BACK )
		{
			pBack->m_aPoints[pBack->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pBack->m_aNormals[pBack->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			pBack->m_nPointCount++;
		}

		// "In front" of clip plane.
		if ( nSides[iPoint] == SIDE_FRONT )
		{
			pFront->m_aPoints[pFront->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pFront->m_aNormals[pFront->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			pFront->m_nPointCount++;
		}

		if ( nSides[iPoint+1] == SIDE_ON || nSides[iPoint+1] == nSides[iPoint] )
			continue;

		// Split!
		float fraction = flDists[iPoint] / ( flDists[iPoint] - flDists[iPoint+1] );

		Vector vecPoint = pClipFace->m_aPoints[iPoint] + ( pClipFace->m_aPoints[(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aPoints[iPoint] ) * fraction;
		Vector vecNormal = pClipFace->m_aNormals[iPoint] + ( pClipFace->m_aNormals[(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aNormals[iPoint] ) * fraction;
		vecNormal.NormalizeInPlace();
		for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
		{
			Vector2D vecTexCoord = pClipFace->m_aTexCoords[iTexCoord][iPoint] + ( pClipFace->m_aTexCoords[iTexCoord][(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aTexCoords[iTexCoord][iPoint] ) * fraction;
			pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = vecTexCoord;
			pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = vecTexCoord;
		}
	
		pFront->m_aPoints[pFront->m_nPointCount] = vecPoint;
		pFront->m_aNormals[pFront->m_nPointCount] = vecNormal;
		pFront->m_nPointCount++;

		pBack->m_aPoints[pBack->m_nPointCount] = vecPoint;
		pBack->m_aNormals[pBack->m_nPointCount] = vecNormal;
		pBack->m_nPointCount++;
	}

	*ppFront = pFront;
	*ppBack = pBack;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_ClipBarycentric( ClipFace_t *pClipFace, cplane_t *pClipPlane, float flEpsilon,
									        int iClip, CMapDisp *pDisp,
									        ClipFace_t **ppFront, ClipFace_t **ppBack )
{
	if ( !pClipFace )
		return;

	float flDists[128];
	int nSides[128];
	int	nSideCounts[3];

	// Determine "sidedness" of all the polygon points.
	nSideCounts[0] = nSideCounts[1] = nSideCounts[2] = 0;
	int iPoint;
	for ( iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
	{
		flDists[iPoint] = pClipPlane->normal.Dot( pClipFace->m_aDispPointUVs.Element( iPoint ) ) - pClipPlane->dist;

		if ( flDists[iPoint] > flEpsilon )
		{
			nSides[iPoint] = SIDE_FRONT;
		}
		else if ( flDists[iPoint] < -flEpsilon )
		{
			nSides[iPoint] = SIDE_BACK;
		}
		else
		{
			nSides[iPoint] = SIDE_ON;
		}

		nSideCounts[nSides[iPoint]]++;
	}

	// Wrap around (close the polygon).
	nSides[iPoint] = nSides[0];
	flDists[iPoint] =  flDists[0];

	// All points in back - no split (copy face to back).
	if( !nSideCounts[SIDE_FRONT] )
	{
		*ppBack = ClipFace_Copy( pClipFace );
		return;
	}

	// All points in front - no split (copy face to front).
	if( !nSideCounts[SIDE_BACK] )
	{
		*ppFront = ClipFace_Copy( pClipFace );
		return;
	}

	// Build new front and back faces.
	// NOTE: We are allowing to go over by 2 and then destroy the surface later.  The old system
	//       allowed for some bad data and we need to be able to load the map and destroy the surface!
	int nMaxPointCount = pClipFace->m_nPointCount + 1;
	ClipFace_t *pFront = ClipFace_Create( nMaxPointCount + 2 );
	ClipFace_t *pBack = ClipFace_Create( nMaxPointCount + 2 );
	if ( !pFront || !pBack )
	{
		ClipFace_Destroy( &pFront );
		ClipFace_Destroy( &pBack );
		return;
	}

	// Reset the counts as they are used to build the surface.
	pFront->m_nPointCount = 0;
	pBack->m_nPointCount = 0;

	for ( iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
	{
		// "On" clip plane.
		if ( nSides[iPoint] == SIDE_ON )
		{
			pFront->m_aPoints[pFront->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pFront->m_aNormals[pFront->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			pFront->m_aDispPointUVs[pFront->m_nPointCount] = pClipFace->m_aDispPointUVs[iPoint];
			
			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			
			ClipFace_CopyBlendFrom( pFront, &pClipFace->m_aBlends[iPoint] );
			pFront->m_nPointCount++;

			pBack->m_aPoints[pBack->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pBack->m_aNormals[pBack->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			pBack->m_aDispPointUVs[pBack->m_nPointCount] = pClipFace->m_aDispPointUVs[iPoint];

			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];

			ClipFace_CopyBlendFrom( pBack, &pClipFace->m_aBlends[iPoint] );
			pBack->m_nPointCount++;

			continue;
		}

		// "In back" of clip plane.
		if ( nSides[iPoint] == SIDE_BACK )
		{
			pBack->m_aPoints[pBack->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pBack->m_aNormals[pBack->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			pBack->m_aDispPointUVs[pBack->m_nPointCount] = pClipFace->m_aDispPointUVs[iPoint];

			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];
			
			ClipFace_CopyBlendFrom( pBack, &pClipFace->m_aBlends[iPoint] );
			pBack->m_nPointCount++;
		}

		// "In front" of clip plane.
		if ( nSides[iPoint] == SIDE_FRONT )
		{
			pFront->m_aPoints[pFront->m_nPointCount] = pClipFace->m_aPoints[iPoint];
			pFront->m_aNormals[pFront->m_nPointCount] = pClipFace->m_aNormals[iPoint];
			pFront->m_aDispPointUVs[pFront->m_nPointCount] = pClipFace->m_aDispPointUVs[iPoint];

			for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
				pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = pClipFace->m_aTexCoords[iTexCoord][iPoint];

			ClipFace_CopyBlendFrom( pFront, &pClipFace->m_aBlends[iPoint] );
			pFront->m_nPointCount++;
		}

		if ( nSides[iPoint+1] == SIDE_ON || nSides[iPoint+1] == nSides[iPoint] )
			continue;

		// Split!
		float fraction = flDists[iPoint] / ( flDists[iPoint] - flDists[iPoint+1] );

		Vector vecPoint = pClipFace->m_aPoints[iPoint] + ( pClipFace->m_aPoints[(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aPoints[iPoint] ) * fraction;
		Vector vecNormal = pClipFace->m_aNormals[iPoint] + ( pClipFace->m_aNormals[(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aNormals[iPoint] ) * fraction;
		vecNormal.NormalizeInPlace();
		Vector vecDispPointUV = pClipFace->m_aDispPointUVs[iPoint] + ( pClipFace->m_aDispPointUVs[(iPoint+1)%pClipFace->m_nPointCount] - pClipFace->m_aDispPointUVs[iPoint] ) * fraction;

		Vector2D vecUV, vecTexCoord;
		PointInQuadToBarycentric( m_pOverlayFace->m_aPoints[0], m_pOverlayFace->m_aPoints[3], 
			                      m_pOverlayFace->m_aPoints[2], m_pOverlayFace->m_aPoints[1],
								  vecPoint, vecUV );

		vecUV.x = clamp( vecUV.x, 0.0f, 1.0f );
		vecUV.y = clamp( vecUV.y, 0.0f, 1.0f );

		for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
		{
			TexCoordInQuadFromBarycentric( m_pOverlayFace->m_aTexCoords[iTexCoord][0], m_pOverlayFace->m_aTexCoords[iTexCoord][3], 
										m_pOverlayFace->m_aTexCoords[iTexCoord][2], m_pOverlayFace->m_aTexCoords[iTexCoord][1],
										vecUV, vecTexCoord );
			
			pFront->m_aTexCoords[iTexCoord][pFront->m_nPointCount] = vecTexCoord;
			pBack->m_aTexCoords[iTexCoord][pBack->m_nPointCount] = vecTexCoord;
		}

		pFront->m_aPoints[pFront->m_nPointCount] = vecPoint;
		pFront->m_aNormals[pFront->m_nPointCount] = vecNormal;
		pFront->m_aDispPointUVs[pFront->m_nPointCount] = vecDispPointUV;
		ClipFace_BuildBlend( pFront, pDisp, pClipPlane, iClip, vecDispPointUV, vecPoint );
		pFront->m_nPointCount++;

		pBack->m_aPoints[pBack->m_nPointCount] = vecPoint;
		pBack->m_aNormals[pBack->m_nPointCount] = vecNormal;
		pBack->m_aDispPointUVs[pBack->m_nPointCount] = vecDispPointUV;
		ClipFace_BuildBlend( pBack, pDisp, pClipPlane, iClip, vecDispPointUV, vecPoint );
		pBack->m_nPointCount++;
	}

	// Check for a bad surface.
	if ( ( pFront->m_nPointCount > nMaxPointCount ) || ( pBack->m_nPointCount > nMaxPointCount ) )
		return;

	*ppFront = pFront;
	*ppBack = pBack;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_PreClipDisp( ClipFace_t *pClipFace, CMapDisp *pDisp )
{
	// Valid clip face and/or displacement surface.
	if ( !pClipFace || !pDisp )
		return;

	// Transform all of the overlay points into disp uv space. 
	for ( int iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
	{
		Vector2D vecTmp;
		pDisp->BaseFacePlaneToDispUV( pClipFace->m_aPoints[iPoint], vecTmp );
				
		pClipFace->m_aDispPointUVs[iPoint].x = clamp(vecTmp.x, 0.0f, 1.0f);
		pClipFace->m_aDispPointUVs[iPoint].y = clamp(vecTmp.y, 0.0f, 1.0f);
		pClipFace->m_aDispPointUVs[iPoint].z = 0.0f;
	}

	// Set initial point barycentric blend types.
	for ( int iPoint = 0; iPoint < pClipFace->m_nPointCount; ++iPoint )
	{
		Vector2D vecDispUV;
		vecDispUV.x = pClipFace->m_aDispPointUVs[iPoint].x;
		vecDispUV.y = pClipFace->m_aDispPointUVs[iPoint].y;

		int iTris[3];
		Vector2D vecVertsUV[3];
		GetTriVerts( pDisp, vecDispUV, iTris, vecVertsUV );

		float flCoefs[3];
		if ( ClipFace_CalcBarycentricCooefs( pDisp, vecVertsUV, vecDispUV, flCoefs ) )
		{
			ClipFace_ResolveBarycentricClip( pDisp, pClipFace, iPoint, vecDispUV, flCoefs, iTris, vecVertsUV );
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_PostClipDisp( void )
{
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CMapOverlay::ClipFace_CalcBarycentricCooefs( CMapDisp *pDisp, Vector2D *pVertsUV, 
												  const Vector2D &vecPointUV, float *pCoefs )
{
	// Area in disp UV space is always the same.
	float flTotalArea = 0.5f;		
	float flOOTotalArea = 1.0f / flTotalArea;

	int nInterval = pDisp->GetWidth();
	Vector2D vecScaledPointUV = vecPointUV * ( nInterval - 1.000001f );

	Vector2D vecSegment0, vecSegment1;

	// Get the area for cooeficient 0 (pt, v1, v2).
	vecSegment0 = pVertsUV[1] - vecScaledPointUV;
	vecSegment1 = pVertsUV[2] - vecScaledPointUV;
	// Cross
	float flSubArea = ( ( vecSegment1.x * vecSegment0.y ) - ( vecSegment0.x * vecSegment1.y ) ) * 0.5f;
	pCoefs[0] = flSubArea * flOOTotalArea;

	// Get the area for cooeficient 1 (v0, pt, v2).
	vecSegment0 = vecScaledPointUV - pVertsUV[0];
	vecSegment1 = pVertsUV[2] - pVertsUV[0];
	// Cross
	flSubArea = ( ( vecSegment1.x * vecSegment0.y ) - ( vecSegment0.x * vecSegment1.y ) ) * 0.5f;
	pCoefs[1] = flSubArea * flOOTotalArea;

	// Get the area for cooeficient 2 (v0, v1, pt).
	vecSegment0 = pVertsUV[1] - pVertsUV[0];
	vecSegment1 = vecScaledPointUV - pVertsUV[0];
	// Cross
	flSubArea = ( ( vecSegment1.x * vecSegment0.y ) - ( vecSegment0.x * vecSegment1.y ) ) * 0.5f;
	pCoefs[2] = flSubArea * flOOTotalArea;

	float flCoefTotal = pCoefs[0] + pCoefs[1] + pCoefs[2];
	if ( FloatMakePositive( 1.0f - flCoefTotal ) < 0.00001f )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_ResolveBarycentricClip( CMapDisp *pDisp, ClipFace_t *pClipFace, int iClipFacePoint, 
										           const Vector2D &vecPointUV, float *pCoefs, 
										           int *pTris, Vector2D *pVertsUV )
{
	int nInterval = pDisp->GetWidth();
	Vector2D vecScaledPointUV = vecPointUV * ( nInterval - 1.000001f );

	// Find the number of coefficients "equal" to zero.
	int nZeroCount = 0;
	bool bZeroPoint[3];
	for ( int iVert = 0; iVert < 3; ++iVert )
	{
		bZeroPoint[iVert] = false;
		if ( fabs( pCoefs[iVert] ) < OVERLAY_BARYCENTRIC_EPSILON )
		{
			nZeroCount++;
			bZeroPoint[iVert] = true;
		}
	}
	
	// Check for points - set to a point.
	if ( nZeroCount == 2 )
	{
		for ( int iVert = 0; iVert < 3; ++iVert )
		{
			if ( !bZeroPoint[iVert] )
			{
				pClipFace->m_aBlends[iClipFacePoint].m_nType = OVERLAY_BLENDTYPE_VERT;
				pClipFace->m_aBlends[iClipFacePoint].m_iPoints[0] = pTris[iVert];
				return;
			}
		}
	}
	
	// Check for edges - setup edge blend.
	if ( nZeroCount == 1 )
	{
		for ( int iVert = 0; iVert < 3; ++iVert )
		{
			if ( bZeroPoint[iVert] )
			{
				pClipFace->m_aBlends[iClipFacePoint].m_nType = OVERLAY_BLENDTYPE_EDGE;
				pClipFace->m_aBlends[iClipFacePoint].m_iPoints[0] = pTris[(iVert+1)%3];
				pClipFace->m_aBlends[iClipFacePoint].m_iPoints[1] = pTris[(iVert+2)%3];
				
				Vector2D vecLength1, vecLength2;
				vecLength1 = vecScaledPointUV - pVertsUV[(iVert+1)%3];
				vecLength2 = pVertsUV[(iVert+2)%3] - pVertsUV[(iVert+1)%3];
				float flBlend = vecLength1.Length() / vecLength2.Length();
				pClipFace->m_aBlends[iClipFacePoint].m_flBlends[0] = flBlend;
				return;
			}
		}
	}
	
	// Lies inside triangles - setup full barycentric blend.
	pClipFace->m_aBlends[iClipFacePoint].m_nType = OVERLAY_BLENDTYPE_BARY;
	pClipFace->m_aBlends[iClipFacePoint].m_iPoints[0] = pTris[0];
	pClipFace->m_aBlends[iClipFacePoint].m_iPoints[1] = pTris[1];
	pClipFace->m_aBlends[iClipFacePoint].m_iPoints[2] = pTris[2];
	pClipFace->m_aBlends[iClipFacePoint].m_flBlends[0] = pCoefs[0];
	pClipFace->m_aBlends[iClipFacePoint].m_flBlends[1] = pCoefs[1];
	pClipFace->m_aBlends[iClipFacePoint].m_flBlends[2] = pCoefs[2];
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CMapOverlay::ClipFace_GetAxisType( cplane_t *pClipPlane )
{
	if ( pClipPlane->normal[0] == 1.0f ) { return OVERLAY_ANGLE90; }
	if ( pClipPlane->normal[1] == 1.0f ) { return OVERLAY_ANGLE0; }
	if ( ( pClipPlane->normal[0] == 0.707f ) && ( pClipPlane->normal[1] == 0.707f ) ) { return OVERLAY_ANGLE45; }
	if ( ( pClipPlane->normal[0] == -0.707f ) && ( pClipPlane->normal[1] == 0.707f ) ) { return OVERLAY_ANGLE135; }

	return OVERLAY_ANGLE0;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_BuildBlend( ClipFace_t *pClipFace, CMapDisp *pDisp, 
									   cplane_t *pClipPlane, int iClip, 
									   const Vector &vecUV, const Vector &vecPoint )
{
	// Get the displacement space interval.
	int nWidth = pDisp->GetWidth();
	int nHeight = pDisp->GetHeight();

	float flU = vecUV.x * ( nWidth - 1.000001f );
	float flV = vecUV.y * ( nHeight - 1.000001f );

	// find the triangle the "uv spot" resides in
	int nSnapU = static_cast<int>( flU );
	int nSnapV = static_cast<int>( flV );
	if ( nSnapU == ( nWidth - 1 ) ) { --nSnapU; }
	if ( nSnapV == ( nHeight - 1 ) ) { --nSnapV; }
	int nNextU = nSnapU + 1;
	int nNextV = nSnapV + 1;

	float flFracU = flU - static_cast<float>( nSnapU );
	float flFracV = flV - static_cast<float>( nSnapV );
		
	int iAxisType = ClipFace_GetAxisType( pClipPlane );
	switch( iAxisType )
	{
	case OVERLAY_ANGLE0:
		{
			// Vert type
			if ( fabs( flFracU ) < OVERLAY_DISPSPACE_EPSILON )
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_VERT;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = ( nWidth * iClip ) + nSnapU;
			}
			// Edge type
			else
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_EDGE;
				int iPoint0 = ( nWidth * iClip ) + nSnapU;
				int iPoint1 = ( nWidth * iClip ) + nNextU;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = iPoint0;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[1] = iPoint1;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_flBlends[0] = flFracU;
			}
			return;
		}
	case OVERLAY_ANGLE45:
		{
			// Vert type
			if ( ( fabs( flFracU ) < OVERLAY_DISPSPACE_EPSILON ) &&
				 ( fabs( flFracV ) < OVERLAY_DISPSPACE_EPSILON ) )
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_VERT;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = ( nWidth * nSnapV ) + nSnapU;
			}
			// Edge type
			else
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_EDGE;
				int iPoint0 = ( nWidth * nNextV ) + nSnapU;
				int iPoint1 = ( nWidth * nSnapV ) + nNextU;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = iPoint0;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[1] = iPoint1;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_flBlends[0] = flFracU;
			}
			return;
		}
	case OVERLAY_ANGLE90:
		{
			// Vert type
			if ( fabs( flFracV ) < OVERLAY_DISPSPACE_EPSILON )
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_VERT;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = ( nWidth * nSnapV ) + iClip;
			}
			// Edge type
			else
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_EDGE;
				int iPoint0 = ( nWidth * nSnapV ) + iClip;
				int iPoint1 = ( nWidth * nNextV ) + iClip;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = iPoint0;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[1] = iPoint1;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_flBlends[0] = flFracV;
			}
			return;
		}
	case OVERLAY_ANGLE135:
		{
			// Vert type
			if ( ( fabs( flFracU ) < OVERLAY_DISPSPACE_EPSILON ) &&
				 ( fabs( flFracV ) < OVERLAY_DISPSPACE_EPSILON ) )
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_VERT;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = ( nWidth * nSnapV ) + nSnapU;
			}
			// Edge type
			else
			{
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = OVERLAY_BLENDTYPE_EDGE;
				int iPoint0 = ( nWidth * nSnapV ) + nSnapU;
				int iPoint1 = ( nWidth * nNextV ) + nNextU;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[0] = iPoint0;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[1] = iPoint1;
				pClipFace->m_aBlends[pClipFace->m_nPointCount].m_flBlends[0] = flFracU;
			}
			return;
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_CopyBlendFrom( ClipFace_t *pClipFace, BlendData_t *pBlendFrom )
{
	pClipFace->m_aBlends[pClipFace->m_nPointCount].m_nType = pBlendFrom->m_nType;
	for ( int iPoint = 0; iPoint < 3; iPoint++ )
	{
		pClipFace->m_aBlends[pClipFace->m_nPointCount].m_iPoints[iPoint] = pBlendFrom->m_iPoints[iPoint];
		pClipFace->m_aBlends[pClipFace->m_nPointCount].m_flBlends[iPoint] = pBlendFrom->m_flBlends[iPoint];
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::ClipFace_BuildFacesFromBlendedData( ClipFace_t *pClipFace )
{
	if( pClipFace->m_pBuildFace->HasDisp() )
	{
		EditDispHandle_t handle = pClipFace->m_pBuildFace->GetDisp();
		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		Vector vecPos[3];
		Vector vecNormal[3];
		for ( int iPoint = 0; iPoint < pClipFace->m_nPointCount; iPoint++ )
		{
			if ( pClipFace->m_aBlends[iPoint].m_nType == OVERLAY_BLENDTYPE_VERT )
			{
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[0], vecPos[0] );
				pClipFace->m_aPoints[iPoint] = vecPos[0];
			}
			else if ( pClipFace->m_aBlends[iPoint].m_nType == OVERLAY_BLENDTYPE_EDGE )
			{
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[0], vecPos[0] );
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[1], vecPos[1] );
				pClipFace->m_aPoints[iPoint] = vecPos[0] + ( vecPos[1] - vecPos[0] ) * pClipFace->m_aBlends[iPoint].m_flBlends[0];
			}
			else if ( pClipFace->m_aBlends[iPoint].m_nType == OVERLAY_BLENDTYPE_BARY )
			{
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[0], vecPos[0] );
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[1], vecPos[1] );
				pDisp->GetVert( pClipFace->m_aBlends[iPoint].m_iPoints[2], vecPos[2] );
				pClipFace->m_aPoints[iPoint] = ( vecPos[0] * pClipFace->m_aBlends[iPoint].m_flBlends[0] ) +
					                           ( vecPos[1] * pClipFace->m_aBlends[iPoint].m_flBlends[1] ) +
								               ( vecPos[2] * pClipFace->m_aBlends[iPoint].m_flBlends[2] );
			}
		}
	}
}


//=============================================================================
//
// CMapOverlay Material Functions
//

int MaxComponent( const Vector &v0 )
{
	int nMax = 0;
	if ( FloatMakePositive( v0[1] ) > FloatMakePositive( v0[nMax] ) )
	{
		nMax = 1;
	}

	if ( FloatMakePositive( v0[2] ) > FloatMakePositive( v0[nMax] ) )
	{
		nMax = 2;
	}

	return nMax;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::Material_Clear( void )
{
	m_Material.m_pTexture = NULL;
	m_Material.m_vecTextureU.Init( 0.0f, 1.0f );
	m_Material.m_vecTextureV.Init( 0.0f, 1.0f );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Material_TexCoordInit( void )
{
	int nMaxU = MaxComponent( m_Basis.m_vecAxes[OVERLAY_BASIS_U] );
	int nMaxV = MaxComponent( m_Basis.m_vecAxes[OVERLAY_BASIS_V] );

	bool bUPos = m_Basis.m_vecAxes[OVERLAY_BASIS_U][nMaxU] >= 0.0f;
	bool bVPos = m_Basis.m_vecAxes[OVERLAY_BASIS_V][nMaxV] >= 0.0f;

	m_Material.m_vecTextureU.Init( 0.0f, 1.0f );
	m_Material.m_vecTextureV.Init( 1.0f, 0.0f );

	if ( ( bUPos && !bVPos ) || ( !bUPos && bVPos ) )
	{
		m_Material.m_vecTextureU.Init( 1.0f, 0.0f );
		m_Material.m_vecTextureV.Init( 0.0f, 1.0f );
	}

	Material_UpdateParentKey();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::Material_Copy( Material_t *pSrc, Material_t *pDst )
{
	pDst->m_pTexture = pSrc->m_pTexture;
	pDst->m_vecTextureU = pSrc->m_vecTextureU;
	pDst->m_vecTextureV = pSrc->m_vecTextureV;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Material_UpdateParentKey( void )
{
	char szValue[80];

	CMapEntity *pEntity = ( CMapEntity* )GetParent();
	if ( pEntity )
	{
		sprintf( szValue, "%g", m_Material.m_vecTextureU.x );
		pEntity->NotifyChildKeyChanged( this, "StartU", szValue );

		sprintf( szValue, "%g", m_Material.m_vecTextureU.y );
		pEntity->NotifyChildKeyChanged( this, "EndU", szValue );

		sprintf( szValue, "%g", m_Material.m_vecTextureV.x );
		pEntity->NotifyChildKeyChanged( this, "StartV", szValue );

		sprintf( szValue, "%g", m_Material.m_vecTextureV.y );
		pEntity->NotifyChildKeyChanged( this, "EndV", szValue );
	}
}

//=============================================================================
//
// CMapOverlay Functions
//

//-----------------------------------------------------------------------------
// Purpose: Construct a CMapOverlay instance.
//-----------------------------------------------------------------------------
CMapOverlay::CMapOverlay() : CMapSideList( "sides" )
{
	Basis_Clear();
	Handles_Clear();
	Material_Clear();

	m_bLoaded = false;
	m_pOverlayFace = NULL;
	m_uiFlags = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Destruct a CMapOverlay instance.
//-----------------------------------------------------------------------------
CMapOverlay::~CMapOverlay()
{
	ClipFace_Destroy( &m_pOverlayFace );
	m_aRenderFaces.PurgeAndDeleteElements();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CMapClass *CMapOverlay::CreateMapOverlay( CHelperInfo *pInfo, CMapEntity *pParent )
{
	CMapOverlay *pOverlay = new CMapOverlay;
	return pOverlay;
}

//-----------------------------------------------------------------------------
// Purpose: Called after the entire map has been loaded. This allows the object
//			to perform any linking with other map objects or to do other operations
//			that require all world objects to be present.
// Input  : pWorld - The world that we are in.
//-----------------------------------------------------------------------------
void CMapOverlay::PostloadWorld( CMapWorld *pWorld )
{
	CMapSideList::PostloadWorld( pWorld );

	// Support older overlay versions which didn't have specific basis axes.
	if ( !Basis_IsValid() )
	{
		Basis_BuildFromSideList();
	}

	Handles_Build3D();
	DoClip();
	CalcBounds();
	m_bLoaded = true;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CMapClass *CMapOverlay::Copy( bool bUpdateDependencies )
{
	CMapOverlay *pCopy = new CMapOverlay;
	if ( pCopy )
	{
		pCopy->CopyFrom( this, bUpdateDependencies );
	}

	return pCopy;
}

void CMapOverlay::Handles_FixOrder()
{
	static bool s_FixingHandles = false;

	// make sure that handle order and plane normal are in sync so CCW culling works correctly
	Vector vNormal = GetNormalFromPoints( m_Handles.m_vec3D[0], m_Handles.m_vec3D[1], m_Handles.m_vec3D[2] );

	if ( DotProduct( vNormal, m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL]) < 0.5 )
	{
		// dont try to fix twice
		if ( s_FixingHandles )
		{
			Assert( !s_FixingHandles );
			return;
		}

		s_FixingHandles = true;

		// Flip handles.
		Vector2D vecCoords[OVERLAY_HANDLES_COUNT];
		for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; iHandle++ )
		{
			vecCoords[4-iHandle-1] = m_Handles.m_vecBasisCoords[iHandle];
		}

		for ( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; iHandle++ )
		{
			m_Handles.m_vecBasisCoords[iHandle] = vecCoords[iHandle];
		}

		// rebuild handles
		
		Handles_Build3D();

		s_FixingHandles = false;
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CMapClass *CMapOverlay::CopyFrom( CMapClass *pObject, bool bUpdateDependencies )
{
	// Verify the object is of the correct type and cast.
	Assert( pObject->IsMapClass( MAPCLASS_TYPE( CMapOverlay ) ) );
	CMapOverlay *pFrom = ( CMapOverlay* )pObject;
	if ( pFrom )
	{
		// Copy the parent class data.
		CMapSideList::CopyFrom( pObject, bUpdateDependencies );

		// Copy basis data.
		Basis_Copy( &pFrom->m_Basis, &m_Basis );

		// Copy handle data.
		Handles_Copy( &pFrom->m_Handles, &m_Handles );

		// Copy material data.
		Material_Copy( &pFrom->m_Material, &m_Material );
	}

	return this;
}

//-----------------------------------------------------------------------------
// Purpose: Notify me when a key has had a data change, so the overlay can
//          update itself appropriately.
//   Input: szKey - the key that changed
//          szValue - the new value (key/data pair)
//-----------------------------------------------------------------------------
void CMapOverlay::OnParentKeyChanged( const char* szKey, const char* szValue )
{
	// Pass this to the sidelist first.
	CMapSideList::OnParentKeyChanged( szKey, szValue );

	// Read side data.
	if ( !stricmp( szKey, "sides" ) )	
	{ 
		if ( m_Faces.Count() > 0 )
		{
			Basis_SetFace( m_Faces.Element( 0 ) );
		}
	}

	// Read geometry data.
	float flDummy;
	if ( !stricmp( szKey, "uv0" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Handles.m_vecBasisCoords[0].x, &m_Handles.m_vecBasisCoords[0].y, &flDummy ); 
		m_Basis.m_nAxesFlip[0] = ( int )flDummy;
	}
	if ( !stricmp( szKey, "uv1" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Handles.m_vecBasisCoords[1].x, &m_Handles.m_vecBasisCoords[1].y, &flDummy ); 
		m_Basis.m_nAxesFlip[1] = ( int )flDummy; 
	}
	if ( !stricmp( szKey, "uv2" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Handles.m_vecBasisCoords[2].x, &m_Handles.m_vecBasisCoords[2].y, &flDummy ); 
		m_Basis.m_nAxesFlip[2] = ( int )flDummy; 
	}
	if ( !stricmp( szKey, "uv3" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Handles.m_vecBasisCoords[3].x, &m_Handles.m_vecBasisCoords[3].y, &flDummy ); 
	}

	// Read basis data.
	if ( !stricmp( szKey, "BasisOrigin" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Basis.m_vecOrigin.x, &m_Basis.m_vecOrigin.y, &m_Basis.m_vecOrigin.z ); 
	}

	if ( !stricmp( szKey, "BasisU" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Basis.m_vecAxes[OVERLAY_BASIS_U].x, &m_Basis.m_vecAxes[OVERLAY_BASIS_U].y, &m_Basis.m_vecAxes[OVERLAY_BASIS_U].z ); 
	}

	if ( !stricmp( szKey, "BasisV" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Basis.m_vecAxes[OVERLAY_BASIS_V].x, &m_Basis.m_vecAxes[OVERLAY_BASIS_V].y, &m_Basis.m_vecAxes[OVERLAY_BASIS_V].z ); 
	}

	if ( !stricmp( szKey, "BasisNormal" ) )     
	{ 
		sscanf( szValue, "%f %f %f", &m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].x, &m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].y, &m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].z ); 
	}

	// Read material data.
	if ( !stricmp( szKey, "material" ) )
	{
		// Get the new material.
		IEditorTexture *pTex = g_Textures.FindActiveTexture( szValue );
		if ( !pTex )
			return;

		// Save the new material.
		m_Material.m_pTexture = pTex;
	}

	if ( !stricmp( szKey, "StartU" ) )	
	{ 
		m_Material.m_vecTextureU.x = atof( szValue ); 
	}
	if ( !stricmp( szKey, "EndU" ) )	
	{ 
		m_Material.m_vecTextureU.y = atof( szValue ); 
	}
	if ( !stricmp( szKey, "StartV" ) )	
	{ 
		m_Material.m_vecTextureV.x = atof( szValue ); 
	}
	if ( !stricmp( szKey, "EndV" ) )	
	{ 
		m_Material.m_vecTextureV.y = atof( szValue ); 
	}

	if ( m_bLoaded )
	{
		// Clip - this needs to be done for everything other than a material change, so go ahead.
		DoClip();
		
		// Post updated.
		PostUpdate( Notify_Changed );
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::OnUndoRedo( void )
{
	PostModified();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::CalcBounds( BOOL bFullUpdate )
{
	// Pass the info along.
	CMapSideList::CalcBounds( bFullUpdate );

	// Verify that we have valid data.
	if ( !Basis_IsValid() )
		return;

	// Calculate the 2d bounds.
	Vector vecMins, vecMaxs;
	vecMins = m_Origin - Vector( 2.0f, 2.0f, 2.0f );
	vecMaxs = m_Origin + Vector( 2.0f, 2.0f, 2.0f );

	// Reset bounds
	m_CullBox.ResetBounds();
	m_Render2DBox.ResetBounds();

	for ( int iHandle = 0; iHandle < 4; ++iHandle )
	{
		for ( int iAxis = 0; iAxis < 3; ++iAxis )
		{
			// Min
			if ( m_Handles.m_vec3D[iHandle][iAxis] < vecMins[iAxis] )
			{
				vecMins[iAxis] = m_Handles.m_vec3D[iHandle][iAxis];
			}

			// Max
			if ( m_Handles.m_vec3D[iHandle][iAxis] > vecMaxs[iAxis] )
			{
				vecMaxs[iAxis] = m_Handles.m_vec3D[iHandle][iAxis];
			}
		}
	}

	// Don't allow for NULL bounds.
	for ( int iAxis = 0; iAxis < 3; ++iAxis )
	{
		if( ( vecMaxs[iAxis] - vecMins[iAxis] ) == 0.0f )
		{
			vecMins[iAxis] -= 0.5f;
			vecMaxs[iAxis] += 0.5f;
		}
	}

	// Update the bounds.
	m_CullBox.UpdateBounds( vecMins, vecMaxs );
	m_BoundingBox = m_CullBox;
	m_Render2DBox.UpdateBounds( vecMins, vecMaxs );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMapOverlay::PostModified( void )
{
	// update face and origin 
	if ( m_Faces.Count() > 0 )
	{
		Basis_SetFace( m_Faces.Element( 0 ) );
		Basis_UpdateOrigin();
	}
	else
	{
		m_Basis.m_pFace = NULL;
	}

	Handles_Build3D();
	DoClip();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : pTransBox - 
//-----------------------------------------------------------------------------
void CMapOverlay::DoTransform( const VMatrix &matrix )
{
	BaseClass::DoTransform( matrix );

	VMatrix tmpMatrix = matrix;
		
	// erase move component
	tmpMatrix.SetTranslation( vec3_origin );

	// check if matrix would still change something 
	if ( !tmpMatrix.IsIdentity() )
	{
		// make sure axes are normalized (they should be anyways)
		m_Basis.m_vecAxes[OVERLAY_BASIS_U].NormalizeInPlace();
		m_Basis.m_vecAxes[OVERLAY_BASIS_V].NormalizeInPlace();

		Vector vecU = m_Basis.m_vecAxes[OVERLAY_BASIS_U];
		Vector vecV = m_Basis.m_vecAxes[OVERLAY_BASIS_V];
		Vector vecNormal = m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL];

		TransformPoint( tmpMatrix, vecU );
		TransformPoint( tmpMatrix, vecV );
		TransformPoint( tmpMatrix, vecNormal );

		float fScaleU = vecU.Length();
		float fScaleV = vecV.Length();
		float flScaleNormal = vecNormal.Length();

		bool bIsUnit = ( fequal( fScaleU, 1.0f, 0.0001 ) && fequal( fScaleV, 1.0f, 0.0001 ) && fequal( flScaleNormal, 1.0f, 0.0001 ) );
		bool bIsPerp = ( fequal( DotProduct( vecU, vecV ), 0.0f, 0.0025 ) && fequal( DotProduct( vecU, vecNormal ), 0.0f, 0.0025 ) && fequal( DotProduct( vecV, vecNormal ), 0.0f, 0.0025 ) );

//		if ( fequal(fScaleU,1,0.0001) && fequal(fScaleV,1,0.0001) && fequal(DotProduct( vecU, vecV ),0,0.0025) )
		if ( bIsUnit && bIsPerp )
		{
			// transformation doesnt scale or shear anything, so just update base axes
			m_Basis.m_vecAxes[OVERLAY_BASIS_U] = vecU;
			m_Basis.m_vecAxes[OVERLAY_BASIS_V] = vecV;
			m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] = vecNormal;
		}
		else
		{
			// more complex transformation, move UV coordinates, but leave base axes 
			for ( int iHandle=0; iHandle<OVERLAY_HANDLES_COUNT;iHandle++)
			{
				Vector2D vecUV = m_Handles.m_vecBasisCoords[iHandle];
				Vector vecPos = ( vecUV.x * m_Basis.m_vecAxes[OVERLAY_BASIS_U] + vecUV.y * m_Basis.m_vecAxes[OVERLAY_BASIS_V] );
				
				// to transform in world space
				TransformPoint( tmpMatrix, vecPos );
				
				vecUV.x = m_Basis.m_vecAxes[OVERLAY_BASIS_U].Dot( vecPos );
				vecUV.y = m_Basis.m_vecAxes[OVERLAY_BASIS_V].Dot( vecPos );

				m_Handles.m_vecBasisCoords[iHandle] = vecUV;
			}

				if ( !Options.IsLockingTextures() )
			{
				// scale textures if locking is off
				m_Material.m_vecTextureU *= fScaleU;
				m_Material.m_vecTextureV *= fScaleV;
				Material_UpdateParentKey();
			}
		}
	}

	// Send modified notice.
	PostModified();

	Handles_UpdateParentKey();
}

//-----------------------------------------------------------------------------
// Purpose: Notifies us that a copy of ourselves was pasted.
//-----------------------------------------------------------------------------
void CMapOverlay::OnPaste( CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, 
						   const CMapObjectList &OriginalList, CMapObjectList &NewList)
{
	//
	// NOTE: currently pCopy is the Overlay being pasted into the world, "this" is
	//       what is being copied from
	//
	CMapSideList::OnPaste( pCopy, pSourceWorld, pDestWorld, OriginalList, NewList );
	CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pCopy );
	if ( pOverlay )
	{
		pOverlay->PostModified();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Notifies us that we created a copy of ourselves (a clone).
//-----------------------------------------------------------------------------
void CMapOverlay::OnClone( CMapClass *pClone, CMapWorld *pWorld, 
						   const CMapObjectList &OriginalList, CMapObjectList &NewList )
{
	CMapSideList::OnClone( pClone, pWorld, OriginalList, NewList );
	CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pClone );
	if ( pOverlay )
	{
		if ( ( GetOverlayType() && OVERLAY_TYPE_SHORE ) == 0 )
		{
			// Update the clone's solid dependencies (this doesn't happen on clone generally).
			int nFaceCount = pOverlay->GetFaceCount();
			for ( int iFace = 0; iFace < nFaceCount; ++iFace )
			{
				CMapFace *pFace = pOverlay->GetFace( iFace );
				CMapSolid *pSolid = ( CMapSolid* )pFace->GetParent();
				pOverlay->UpdateDependency( NULL, pSolid );
			}
		}

		pOverlay->PostModified();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Notifys this decal of a change to a solid that it is attached to.
//-----------------------------------------------------------------------------
void CMapOverlay::OnNotifyDependent( CMapClass *pObject, Notify_Dependent_t eNotifyType )
{
	// Chain to base class FIRST so it can rebuild the face list if necessary.
	CMapSideList::OnNotifyDependent( pObject, eNotifyType );

	//
	// NOTE: the solid moving (changing) can update the overlay/solid(face) dependency
	//       so "rebuild" the overlay
	//
	switch ( eNotifyType )
	{
	case Notify_Changed:
	case Notify_Undo:
	case Notify_Transform:
		{
			PostModified();
			break;
		}
	case Notify_Removed:
	case Notify_Clipped:
		{
			m_aRenderFaces.Purge();
			PostModified();
			break;
		}
	case Notify_Rebuild:
		{
			UpdateDispBarycentric();
			break;
		}
	case Notify_Rebuild_Full:
		{
			DoClip();
			CenterEntity();
			Handles_Build3D();
			break;
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::Render3D( CRender3D *pRender )
{
	int nFaceCount = m_aRenderFaces.Count();

	if ( nFaceCount != 0 )
	{
		// dont draw textured during manipulating
		if ( GetSelectionState() != SELECT_MODIFY )
		{

			// Bind the matrial -- if there is one!!
			bool bTextured = false;
			if ( m_Material.m_pTexture )
			{
				pRender->BindTexture( m_Material.m_pTexture );
				pRender->PushRenderMode( RENDER_MODE_TEXTURED );
				bTextured = true;
			}
			else
			{
				// Default state.
				pRender->PushRenderMode( RENDER_MODE_FLAT );
			}
			
			for ( int iFace = 0; iFace < nFaceCount; iFace++ )
			{
				ClipFace_t *pRenderFace = m_aRenderFaces.Element( iFace );
				if( !pRenderFace )
					continue;
				
				MaterialPrimitiveType_t type = MATERIAL_POLYGON;
				
				// Get a dynamic mesh.
				CMeshBuilder meshBuilder;
				CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
				IMesh* pMesh = pRenderContext->GetDynamicMesh();
				
				meshBuilder.Begin( pMesh, type, pRenderFace->m_nPointCount );
				for ( int iPoint = 0; iPoint < pRenderFace->m_nPointCount; iPoint++ )
				{
					if ( !bTextured )
					{
						meshBuilder.Color3ub( 0, 128, 0 );
					}
					else
					{
						meshBuilder.TexCoord2f( 0, pRenderFace->m_aTexCoords[0][iPoint].x, pRenderFace->m_aTexCoords[0][iPoint].y );
						meshBuilder.TexCoord2f( 2, pRenderFace->m_aTexCoords[1][iPoint].x, pRenderFace->m_aTexCoords[1][iPoint].y );
						meshBuilder.Color4ub( 255, 255, 255, 255 );
					}
					meshBuilder.Position3f( pRenderFace->m_aPoints[iPoint].x, pRenderFace->m_aPoints[iPoint].y, pRenderFace->m_aPoints[iPoint].z );
					meshBuilder.Normal3f( pRenderFace->m_aNormals[iPoint].x, pRenderFace->m_aNormals[iPoint].y, pRenderFace->m_aNormals[iPoint].z );
					meshBuilder.AdvanceVertex();
				}
				meshBuilder.End();
				
				pMesh->Draw();
			}
			pRender->PopRenderMode();
		}
		
		// Render wireframe on top when seleted.
		if ( GetSelectionState() != SELECT_NONE )
		{
			pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
			for ( int iFace = 0; iFace < nFaceCount; iFace++ )
			{
				ClipFace_t *pRenderFace = m_aRenderFaces.Element( iFace );
				if( !pRenderFace )
					continue;
				
				MaterialPrimitiveType_t type = MATERIAL_LINE_LOOP;
				
				// get a dynamic mesh
				CMeshBuilder meshBuilder;
				CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
				IMesh* pMesh = pRenderContext->GetDynamicMesh();
				
				meshBuilder.Begin( pMesh, type, pRenderFace->m_nPointCount );
				for( int iPoint = 0; iPoint < pRenderFace->m_nPointCount; iPoint++ )
				{
					meshBuilder.Color3ub( 0, 255, 0 );
					meshBuilder.Position3f( pRenderFace->m_aPoints[iPoint].x, pRenderFace->m_aPoints[iPoint].y, pRenderFace->m_aPoints[iPoint].z );
					meshBuilder.Normal3f( pRenderFace->m_aNormals[iPoint].x, pRenderFace->m_aNormals[iPoint].y, pRenderFace->m_aNormals[iPoint].z );
					meshBuilder.AdvanceVertex();
				}
				meshBuilder.End();
				
				pMesh->Draw();
			}
			pRender->PopRenderMode();
		}
	}

	// Render the handles - if selected or in overlay tool mode.
	if ( ( ToolManager()->GetActiveToolID() == TOOL_OVERLAY ) && Basis_IsValid() && IsSelected() )
	{
		Handles_Render3D( pRender );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Clip the overlay "face" to all of the faces in the overlay sidelist.
//          The sidelist defines all faces affected by the "overlay."
//-----------------------------------------------------------------------------
void CMapOverlay::DoClip( void )
{
	// Check to see if we have any faces to clip against.
	int nFaceCount = m_Faces.Count();
	if( nFaceCount == 0 )
		return;

	// Destroy the render face cache.
	m_aRenderFaces.Purge();

	// clip the overlay against all faces in the sidelist
	for ( int iFace = 0; iFace < nFaceCount; iFace++ )
	{
		CMapFace *pFace = m_Faces.Element( iFace );
		if ( pFace )
		{
			PreClip();
			DoClipFace( pFace );
			PostClip();
		}
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::PreClip( void )
{
	//
	// Create the initial face to be clipped - the overlay.
	//
	m_pOverlayFace = ClipFace_Create( OVERLAY_HANDLES_COUNT );
	if ( m_pOverlayFace )
	{
		for ( int iPoint = 0; iPoint < OVERLAY_HANDLES_COUNT; iPoint++ )
		{
			OverlayUVToOverlayPlane( m_Handles.m_vecBasisCoords[iPoint], m_pOverlayFace->m_aPoints[iPoint] );

			// translate texture UV to texture coords:
			Vector2D vTexCoord;
			switch( iPoint )
			{
				case 0 : vTexCoord = Vector2D(m_Material.m_vecTextureU.x, m_Material.m_vecTextureV.x); break;
				case 1 : vTexCoord = Vector2D(m_Material.m_vecTextureU.x, m_Material.m_vecTextureV.y); break;
				case 2 : vTexCoord = Vector2D(m_Material.m_vecTextureU.y, m_Material.m_vecTextureV.y); break;
				case 3 : vTexCoord = Vector2D(m_Material.m_vecTextureU.y, m_Material.m_vecTextureV.x); break;
				default : Assert( iPoint <= OVERLAY_HANDLES_COUNT);
			}

			m_pOverlayFace->m_aTexCoords[0][iPoint] = vTexCoord;

			if ( m_Basis.m_pFace->HasDisp() )
			{
				EditDispHandle_t handle = m_Basis.m_pFace->GetDisp();
				CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
				if ( pDisp )
				{
					Vector2D vecTmp;
					pDisp->BaseFacePlaneToDispUV( m_pOverlayFace->m_aPoints[iPoint], vecTmp );
					m_pOverlayFace->m_aDispPointUVs[iPoint].x = vecTmp.x;
					m_pOverlayFace->m_aDispPointUVs[iPoint].y = vecTmp.y;
					m_pOverlayFace->m_aDispPointUVs[iPoint].z = 0.0f;
				}
			}
		}
		// The second set of texcoords on the overlay is used for alpha by certain shaders,
		// and they want to stretch the texture across the whole overlay.
		m_pOverlayFace->m_aTexCoords[1][0].Init( 0, 0 );
		m_pOverlayFace->m_aTexCoords[1][1].Init( 0, 1 );
		m_pOverlayFace->m_aTexCoords[1][2].Init( 1, 1 );
		m_pOverlayFace->m_aTexCoords[1][3].Init( 1, 0 );
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::PostClip( void )
{
	ClipFace_Destroy( &m_pOverlayFace );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::DoClipFace( CMapFace *pFace )
{
	// Valid face?
	Assert( pFace != NULL );
	if( !pFace )
		return;

	// Copy the original overlay to the "clipped" overlay.
	ClipFace_t *pClippedFace = ClipFace_Copy( m_pOverlayFace );
	if ( !pClippedFace )
		return;

	//
	// Project all face points into the overlay plane.
	//
	int nPointCount = pFace->nPoints;
	Vector *pPoints = new Vector[nPointCount];
	int	nEdgePlaneCount = nPointCount;
	cplane_t *pEdgePlanes = new cplane_t[nEdgePlaneCount];
	if ( !pPoints || !pEdgePlanes )
	{
		delete [] pPoints;
		delete [] pEdgePlanes;
		return;
	}

	for ( int iPoint = 0; iPoint < nPointCount; iPoint++ )
	{
		WorldToOverlayPlane( pFace->Points[iPoint], pPoints[iPoint] );
	}

	// Create the face clipping planes (edges cross overlay plane normal).
	BuildEdgePlanes( pPoints, nPointCount, pEdgePlanes, nEdgePlaneCount );

	//
	// Clip overlay against all the edge planes.
	//
	for ( int iClipPlane = 0; iClipPlane < nEdgePlaneCount; iClipPlane++ )
	{
		ClipFace_t *pFront = NULL;
		ClipFace_t *pBack = NULL;

		if ( pClippedFace )
		{
			// Clip the overlay and delete the data (we are done with it - we are only interested in what is left).
			ClipFace_Clip( pClippedFace, &pEdgePlanes[iClipPlane], OVERLAY_WORLDSPACE_EPSILON, &pFront, &pBack );
			ClipFace_Destroy( &pClippedFace );

			// Keep the backside -- if it exists and continue clipping.
			if ( pBack )
			{
				pClippedFace = pBack;
			}

			// Destroy the front side -- if it exists.
			if ( pFront )
			{
				ClipFace_Destroy( &pFront );
			}
		}
	}

	//
	// Free temporary memory (clip planes and point).
	//
	delete [] pPoints;
	delete [] pEdgePlanes;


	//
	// If it exists, move points from the overlay plane back into
	// the base face plane.
	//
	if ( !pClippedFace )
		return;

	for ( int iPoint = 0; iPoint < pClippedFace->m_nPointCount; iPoint++ )
	{
		Vector2D vecUV;
		PointInQuadToBarycentric( m_pOverlayFace->m_aPoints[0], m_pOverlayFace->m_aPoints[3], 
			                      m_pOverlayFace->m_aPoints[2], m_pOverlayFace->m_aPoints[1],
								  pClippedFace->m_aPoints[iPoint], vecUV );

		Vector vecTmp;
		OverlayPlaneToWorld( pFace, pClippedFace->m_aPoints[iPoint], vecTmp );
		pClippedFace->m_aPoints[iPoint] = vecTmp;

		Vector2D vecTexCoord;
		for ( int iTexCoord=0; iTexCoord < NUM_CLIPFACE_TEXCOORDS; iTexCoord++ )
		{
			TexCoordInQuadFromBarycentric( m_pOverlayFace->m_aTexCoords[iTexCoord][0], m_pOverlayFace->m_aTexCoords[iTexCoord][3],
										m_pOverlayFace->m_aTexCoords[iTexCoord][2], m_pOverlayFace->m_aTexCoords[iTexCoord][1],
										vecUV, vecTexCoord );
			
			pClippedFace->m_aTexCoords[iTexCoord][iPoint] = vecTexCoord;
		}
	}

	//
	// If the face has a displacement map -- continue clipping.
	//
	if( pFace->HasDisp() )
	{
		DoClipDisp( pFace, pClippedFace );
	}
	// Done - save it!
	else
	{
		pClippedFace->m_pBuildFace = pFace;
		m_aRenderFaces.AddToTail( pClippedFace );
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CMapOverlay::BuildEdgePlanes( Vector const *pPoints, int nPointCount,
								   cplane_t *pEdgePlanes, int nEdgePlaneCount )
{
	for ( int iPoint = 0; iPoint < nPointCount; iPoint++ )
	{
		Vector vecEdge;
		vecEdge = pPoints[(iPoint+1)%nPointCount] - pPoints[iPoint];
		VectorNormalize( vecEdge );

		pEdgePlanes[iPoint].normal = m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].Cross( vecEdge );
		pEdgePlanes[iPoint].dist = pEdgePlanes[iPoint].normal.Dot( pPoints[iPoint] );

		// Check normal facing.
		float flDist = pEdgePlanes[iPoint].normal.Dot( pPoints[(iPoint+2)%nPointCount] ) - pEdgePlanes[iPoint].dist;
		if( flDist > 0.0f )
		{
			// flip
			pEdgePlanes[iPoint].normal.Negate();
			pEdgePlanes[iPoint].dist = -pEdgePlanes[iPoint].dist;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Disp_ClipFragments( CMapDisp *pDisp, ClipFaces_t &aDispFragments )
{
	cplane_t clipPlane;

	// Cache the displacement interval.
	int nInterval = pDisp->GetWidth() - 1;

	// Displacement-space clipping in V.
	clipPlane.normal.Init( 1.0f, 0.0f, 0.0f );
	Disp_DoClip( pDisp, aDispFragments, clipPlane, 1.0f, nInterval, 1, nInterval, 1 );

	// Displacement-space clipping in U.
	clipPlane.normal.Init( 0.0f, 1.0f, 0.0f );
	Disp_DoClip( pDisp, aDispFragments, clipPlane, 1.0f, nInterval, 1, nInterval, 1 );

	// Displacement-space clipping UV from top-left to bottom-right.
	clipPlane.normal.Init( 0.707f, 0.707f, 0.0f );  // 45 degrees
	Disp_DoClip( pDisp, aDispFragments, clipPlane, 0.707f, nInterval, 2, ( nInterval * 2 - 1 ), 2 );

	// Displacement-space clipping UV from bottom-left to top-right.
	clipPlane.normal.Init( -0.707f, 0.707f, 0.0f );  // 135 degrees
	Disp_DoClip( pDisp, aDispFragments, clipPlane, 0.707f, nInterval, -( nInterval - 2 ), ( nInterval - 1 ), 2 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::Disp_DoClip( CMapDisp *pDisp, ClipFaces_t &aDispFragments,
							   cplane_t &clipPlane, float clipDistStart, int nInterval,
							   int nLoopStart, int nLoopEnd, int nLoopInc )
{
	// Setup interval information.
	float flInterval = static_cast<float>( nInterval );
	float flOOInterval = 1.0f / flInterval;

	// Holds the current set of clipped faces.
	ClipFaces_t aClippedFragments;

	for ( int iInterval = nLoopStart; iInterval < nLoopEnd; iInterval += nLoopInc )
	{
		// Copy the current list to clipped face list.
		aClippedFragments.CopyArray( aDispFragments.Base(), aDispFragments.Count() );
		aDispFragments.Purge();

		// Clip in V.
		int nFragCount = aClippedFragments.Count();
		for ( int iFrag = 0; iFrag < nFragCount; iFrag++ )
		{
			ClipFace_t *pClipFrag = aClippedFragments[iFrag];
			if ( pClipFrag )
			{
				ClipFace_t *pFront = NULL, *pBack = NULL;

				clipPlane.dist = clipDistStart * ( ( float )iInterval * flOOInterval );
				ClipFace_ClipBarycentric( pClipFrag, &clipPlane, OVERLAY_DISPSPACE_EPSILON, iInterval, pDisp, &pFront, &pBack );
				ClipFace_Destroy( &pClipFrag );

				if ( pFront )
				{
					aDispFragments.AddToTail( pFront );
				}

				if ( pBack )
				{
					aDispFragments.AddToTail( pBack );
				}
			}
		}
	}

	// Clean up!
	aClippedFragments.Purge();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::DoClipDisp( CMapFace *pFace, ClipFace_t *pClippedFace )
{
	// Get the displacement data.
	EditDispHandle_t handle = pFace->GetDisp();
	CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

	// Initialize local clip data.
	ClipFace_PreClipDisp( pClippedFace, pDisp );

	// Setup clipped face lists.
	ClipFaces_t aCurrentFaces;
	aCurrentFaces.AddToTail( pClippedFace );

	Disp_ClipFragments( pDisp, aCurrentFaces );

	//
	// Project points back onto the displacement surface.
	//
	int nFaceCount = aCurrentFaces.Count();
	for( int iFace = 0; iFace < nFaceCount; iFace++ )
	{	
		ClipFace_t *pClipFace = aCurrentFaces[iFace];
		if ( pClipFace )
		{
			// Save for re-building later!
			pClipFace->m_pBuildFace = pFace;
			m_aRenderFaces.AddToTail( aCurrentFaces[iFace] );
			ClipFace_BuildFacesFromBlendedData( pClipFace );
		}
	}

	// Clean up!
	aCurrentFaces.Purge();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::HandlesReset( void )
{
	m_Handles.m_iHit = -1;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CMapOverlay::HandlesHitTest( CMapView *pView, const Vector2D &vPoint )
{
	int handleRadius = 8;

	for ( int iPoint = 0; iPoint < 4; iPoint++ )
	{
		Vector2D vHandle; 

		pView->WorldToClient( vHandle, m_Handles.m_vec3D[iPoint] );
		
		if ( vPoint.x < (vHandle.x-handleRadius) || vPoint.x > ( vHandle.x+handleRadius) )
			continue;

		if ( vPoint.y < (vHandle.y-handleRadius) || vPoint.y > ( vHandle.y+handleRadius) )
			continue;

		m_Handles.m_iHit = iPoint;
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::HandlesDragTo( Vector &vecImpact, CMapFace *pFace )
{
	// Check handle index range.
	if ( ( m_Handles.m_iHit < 0 ) || ( m_Handles.m_iHit > 3 ) )
		return;

	// Save
	m_Handles.m_vec3D[m_Handles.m_iHit] = vecImpact;

	// Project the point into the overlay plane (from face/disp).
	Vector vecOverlay;
	Vector2D vecUVOverlay;
	Handles_SurfToOverlayPlane( pFace, vecImpact, vecOverlay );
	OverlayPlaneToOverlayUV( vecOverlay, vecUVOverlay );
	m_Handles.m_vecBasisCoords[m_Handles.m_iHit] = vecUVOverlay;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::HandleMoveTo( int iHandle, Vector &vecPoint, CMapFace *pFace )
{
	if ( ( iHandle < 0 ) || ( iHandle > 3 ) )
		return;

	m_Handles.m_vec3D[iHandle] = vecPoint;

	// Project the point into the overlay plane (from face/disp).
	Vector vecOverlay;
	Vector2D vecUVOverlay;
	Handles_SurfToOverlayPlane( pFace, vecPoint, vecOverlay );
	OverlayPlaneToOverlayUV( vecOverlay, vecUVOverlay );
	m_Handles.m_vecBasisCoords[iHandle] = vecUVOverlay;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::SetTexCoords( Vector2D vecTexCoords[4] )
{
	m_Material.m_vecTextureU.x = vecTexCoords[0][0];
	m_Material.m_vecTextureV.x = vecTexCoords[0][1];
//	m_Material.m_vecTextureU.x = vecTexCoord[1][0];
	m_Material.m_vecTextureV.y = vecTexCoords[1][1];
	m_Material.m_vecTextureU.y = vecTexCoords[2][0];
//	m_Material.m_vecTextureV.y = vecTexCoord[2][1];
//	m_Material.m_vecTextureU.y = vecTexCoord[3][0];
//	m_Material.m_vecTextureV.x = vecTexCoord[3][1];
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::UpdateDispBarycentric( void )
{
	//
	// Project points back onto the displacement surface.
	//
	int nFaceCount = m_aRenderFaces.Count();
	for ( int iFace = 0; iFace < nFaceCount; iFace++ )
	{
		// Get the current face and remove it from the list.
		ClipFace_t *pClipFace = m_aRenderFaces[iFace];
		if ( pClipFace )
		{
			if ( pClipFace->m_pBuildFace->HasDisp() )
			{
				ClipFace_BuildFacesFromBlendedData( pClipFace );
			}
		}
	}

	// Update the entity position.
	CenterEntity();

	// Update the handles.
	Handles_Build3D();
}

//-----------------------------------------------------------------------------
// Purpose:  
//-----------------------------------------------------------------------------
void CMapOverlay::CenterEntity( void )
{
	// Center in overlay plane.
	Vector vecTotal;
	Vector vecHandle;

	vecTotal.Init();
	for( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; ++iHandle )
	{
		OverlayUVToOverlayPlane( m_Handles.m_vecBasisCoords[iHandle], vecHandle );
		vecTotal += vecHandle;
	}
	vecTotal *= 0.25f;

	// Center in overlay uv-space.
	Vector2D vecNewCenter;
	OverlayPlaneToOverlayUV( vecTotal, vecNewCenter );
	for( int iHandle = 0; iHandle < OVERLAY_HANDLES_COUNT; ++iHandle )
	{
		m_Handles.m_vecBasisCoords[iHandle] -= vecNewCenter;
	}

	// Update the entity's origin.
	m_Basis.m_vecOrigin = vecTotal;

	CMapEntity *pEntity = ( CMapEntity* )GetParent();
	if ( pEntity )
	{
		Vector vecSurfPoint;
		OverlayPlaneToSurfFromList( vecTotal, vecSurfPoint );
		pEntity->SetOrigin( vecSurfPoint );
	}

	// Update the property box.
	Basis_UpdateParentKey();
	Handles_UpdateParentKey();
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::GetPlane( cplane_t &plane )
{
	plane.normal = m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL];
	plane.dist = plane.normal.Dot( m_Basis.m_vecOrigin );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::GetHandlePos( int iHandle, Vector &vecPos )
{
	Assert( iHandle >= 0 );
	Assert( iHandle < 4 );

	vecPos = m_Handles.m_vec3D[iHandle];
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::SideList_Init( CMapFace *pFace )
{
	// Valid face?
	if ( !pFace )
		return;

	// Purge side list as this should be the initial face!
	m_Faces.Purge();
	m_Faces.AddToTail( pFace );

	if ( ( GetOverlayType() && OVERLAY_TYPE_SHORE ) == 0 )
	{
		// Update dependencies.
		UpdateDependency( NULL, ( CMapSolid* )pFace->GetParent() );
		UpdateParentKey();
	}

	// Initialize the overlay.
	Basis_Init( pFace );
	PostModified();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::SideList_AddFace( CMapFace *pFace )
{
	// Valid face?
	if ( !pFace )
		return;

	// Purge side list as this should be the initial face!
	m_Faces.AddToTail( pFace );

	if ( ( GetOverlayType() && OVERLAY_TYPE_SHORE ) == 0 )
	{
		// Update dependencies.
		UpdateDependency( NULL, ( CMapSolid* )pFace->GetParent() );
		UpdateParentKey();
	}

	PostModified();
}

//=============================================================================
//
// Overlay Utility Functions
//

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::OverlayUVToOverlayPlane( const Vector2D &vecUV, Vector &vecOverlayPoint )
{
	vecOverlayPoint = ( vecUV.x * m_Basis.m_vecAxes[OVERLAY_BASIS_U] +
		                vecUV.y * m_Basis.m_vecAxes[OVERLAY_BASIS_V] );
	vecOverlayPoint += m_Basis.m_vecOrigin;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::OverlayPlaneToOverlayUV( const Vector &vecOverlayPoint, Vector2D &vecUV )
{
	Vector vecDelta;
	vecDelta = vecOverlayPoint - m_Basis.m_vecOrigin;
	vecUV.x = m_Basis.m_vecAxes[OVERLAY_BASIS_U].Dot( vecDelta );
	vecUV.y = m_Basis.m_vecAxes[OVERLAY_BASIS_V].Dot( vecDelta );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::WorldToOverlayPlane( const Vector &vecWorldPoint, Vector &vecOverlayPoint )
{
	Vector vecDelta = vecWorldPoint - m_Basis.m_vecOrigin;
	float flDist = m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL].Dot( vecDelta );
	vecOverlayPoint = vecWorldPoint - ( m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] * flDist );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::OverlayPlaneToWorld( CMapFace *pFace, const Vector &vecOverlayPoint,
									   Vector &vecWorldPoint )
{
	// Create the overlay plane - the base face plane.
	cplane_t surfacePlane;
	pFace->GetFaceNormal( surfacePlane.normal );
	VectorNormalize( surfacePlane.normal );
	Vector vecPoint;
	pFace->GetPoint( vecPoint, 0 );
	surfacePlane.dist = surfacePlane.normal.Dot( vecPoint );

	float flDistToSurface = surfacePlane.normal.Dot( vecOverlayPoint ) - surfacePlane.dist;
	float flDist = flDistToSurface;
	float flDot = surfacePlane.normal.Dot( m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] );
	if ( flDot != 0.0f )
	{
		flDist = ( 1.0f / flDot ) * flDistToSurface;
	}

	vecWorldPoint = vecOverlayPoint - ( m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] * flDist );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMapOverlay::OverlayPlaneToSurfFromList( const Vector &vecOverlayPoint, Vector &vecSurfPoint )
{
	// Initialize the point with the overlay point.
	vecSurfPoint = vecOverlayPoint;

	int nFaceCount = GetFaceCount();
	CUtlVector<Vector> aPoints;
	CUtlVector<cplane_t> aPlanes;

	for ( int iFace = 0; iFace < nFaceCount; ++iFace )
	{
		CMapFace *pFace = GetFace( iFace );
		if ( !pFace )
			continue;

		// Set points.
		aPoints.Purge();
		aPoints.SetSize( pFace->nPoints );
		aPlanes.Purge();
		aPlanes.SetSize( pFace->nPoints );

		// Project all the face points into the overlay plane.
		for ( int iPoint = 0; iPoint < pFace->nPoints; ++iPoint )
		{
			WorldToOverlayPlane( pFace->Points[iPoint], aPoints[iPoint] );
		}

		// Create edge planes for clipping.
		BuildEdgePlanes( aPoints.Base(), aPoints.Count(), aPlanes.Base(), aPlanes.Count() );

		// Check to see if a point lies behind all of the edge planes - this is our face.
		int iPlane;
		for ( iPlane = 0; iPlane < aPlanes.Count(); ++iPlane )
		{
			float flDist = aPlanes[iPlane].normal.Dot( vecOverlayPoint ) - aPlanes[iPlane].dist;
			if( flDist >= 0.0f )
				break;
		}

		// Point lies outside off at least one plane.
		if( iPlane != aPlanes.Count() )
		{
			continue;
		}

		// Project the point up to the base face plane (displacement if necessary).
		OverlayPlaneToWorld( pFace, vecOverlayPoint, vecSurfPoint );
		
		if( pFace->HasDisp() )
		{
			Vector2D vecTmp;
			EditDispHandle_t handle = pFace->GetDisp();
			CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
			pDisp->BaseFacePlaneToDispUV( vecSurfPoint, vecTmp );
			pDisp->DispUVToSurf( vecTmp, vecSurfPoint, NULL, NULL );
		}

		// Clean-up.
		aPoints.Purge();
		aPlanes.Purge();
		return;
	}

	// Clean-up.
	aPoints.Purge();
	aPlanes.Purge();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CMapOverlay::EntityOnSurfFromListToBaseFacePlane( const Vector &vecWorldPoint, Vector &vecBasePoint )
{
	int nFaceCount = GetFaceCount();
	for ( int iFace = 0; iFace < nFaceCount; ++iFace )
	{
		CMapFace *pFace = GetFace( iFace );
		if ( !pFace )
			continue;
		
		if ( !pFace->HasDisp() )
			continue;

		EditDispHandle_t handle = pFace->GetDisp();
		CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );

		if ( pDisp->SurfToBaseFacePlane( vecWorldPoint, vecBasePoint ) )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::GetTriVerts( CMapDisp *pDisp, const Vector2D &vecSurfUV, int *pTris, Vector2D *pVertsUV )
{
	// Get the displacement width.
	int nWidth = pDisp->GetWidth();
	int nHeight = pDisp->GetHeight();

	// scale the u, v coordinates the displacement grid size
	float flU = vecSurfUV.x * ( nWidth - 1.000001f );
	float flV = vecSurfUV.y * ( nHeight - 1.000001f );

	// find the triangle the "uv spot" resides in
	int nSnapU = static_cast<int>( flU );
	int nSnapV = static_cast<int>( flV );
	if ( nSnapU == ( nWidth - 1 ) ) { --nSnapU; }
	if ( nSnapV == ( nHeight - 1 ) ) { --nSnapV; }
	int nNextU = nSnapU + 1;
	int nNextV = nSnapV + 1;
	
	// Fractional portion
	float flFracU = flU - static_cast<float>( nSnapU );
	float flFracV = flV - static_cast<float>( nSnapV );

	bool bOdd = ( ( ( nSnapV * nWidth ) + nSnapU ) % 2 ) == 1;
	if ( bOdd )
	{
		if( ( flFracU + flFracV ) >= ( 1.0f + OVERLAY_DISPSPACE_EPSILON ) )
		{
			pVertsUV[0].x = nSnapU;  pVertsUV[0].y = nNextV;
			pVertsUV[1].x = nNextU;  pVertsUV[1].y = nNextV;
			pVertsUV[2].x = nNextU;  pVertsUV[2].y = nSnapV;
		}
		else
		{
			pVertsUV[0].x = nSnapU;  pVertsUV[0].y = nSnapV;
			pVertsUV[1].x = nSnapU;  pVertsUV[1].y = nNextV;
			pVertsUV[2].x = nNextU;  pVertsUV[2].y = nSnapV;
		}
	}
	else
	{
		if ( flFracU < flFracV )
		{
			pVertsUV[0].x = nSnapU;  pVertsUV[0].y = nSnapV;
			pVertsUV[1].x = nSnapU;  pVertsUV[1].y = nNextV;
			pVertsUV[2].x = nNextU;  pVertsUV[2].y = nNextV;
		}
		else
		{
			pVertsUV[0].x = nSnapU;  pVertsUV[0].y = nSnapV;
			pVertsUV[1].x = nNextU;  pVertsUV[1].y = nNextV;
			pVertsUV[2].x = nNextU;  pVertsUV[2].y = nSnapV;
		}
	}

	// Calculate the triangle indices.
	for( int iVert = 0; iVert < 3; ++iVert )
	{
		pTris[iVert] = pVertsUV[iVert].y * nWidth + pVertsUV[iVert].x;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapOverlay::SetMaterial( const char *szMaterialName )
{
	// Get the new material.
	IEditorTexture *pTex = g_Textures.FindActiveTexture( szMaterialName );
	if ( !pTex )
		return;
	
	// Save the new material.
	m_Material.m_pTexture = pTex;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapOverlay::SaveDataToVMF( CChunkFile *pFile, CSaveInfo *pSaveInfo )
{
	ChunkFileResult_t eResult = pFile->BeginChunk("overlaydata");

	// Save the material name.
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValue( "material", m_Material.m_pTexture->GetName() );
	}

	// Save the u,v data.
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueFloat( "StartU", m_Material.m_vecTextureU.x );
	}
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueFloat( "EndU", m_Material.m_vecTextureU.y );
	}

	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueFloat( "StartV", m_Material.m_vecTextureV.x );
	}
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueFloat( "EndV", m_Material.m_vecTextureV.y );
	}

	// Basis data.
	Vector vecTmp;
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueVector3( "BasisOrigin", m_Basis.m_vecOrigin );
	}
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueVector3( "BasisU", m_Basis.m_vecAxes[OVERLAY_BASIS_U] );
	}
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueVector3( "BasisV", m_Basis.m_vecAxes[OVERLAY_BASIS_V] );
	}
	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->WriteKeyValueVector3( "BasisNormal", m_Basis.m_vecAxes[OVERLAY_BASIS_NORMAL] );
	}

	if ( eResult == ChunkFile_Ok )
	{
		Vector vecTmp( m_Handles.m_vecBasisCoords[0].x, m_Handles.m_vecBasisCoords[0].y, ( float )m_Basis.m_nAxesFlip[0] );
		eResult = pFile->WriteKeyValueVector3( "uv0", vecTmp );
	}
	if ( eResult == ChunkFile_Ok )
	{
		Vector vecTmp( m_Handles.m_vecBasisCoords[1].x, m_Handles.m_vecBasisCoords[1].y, ( float )m_Basis.m_nAxesFlip[1] );
		eResult = pFile->WriteKeyValueVector3( "uv1", vecTmp );
	}
	if ( eResult == ChunkFile_Ok ) 
	{
		Vector vecTmp( m_Handles.m_vecBasisCoords[2].x, m_Handles.m_vecBasisCoords[2].y, ( float )m_Basis.m_nAxesFlip[2] );
		eResult = pFile->WriteKeyValueVector3( "uv2", vecTmp );
	}
	if ( eResult == ChunkFile_Ok )
	{
		Vector vecTmp( m_Handles.m_vecBasisCoords[3].x, m_Handles.m_vecBasisCoords[3].y, 0.0f );
		eResult = pFile->WriteKeyValueVector3( "uv3", vecTmp );
	}
 
	// Sidelist.
	if ( eResult == ChunkFile_Ok )
	{
		char szSetValue[KEYVALUE_MAX_VALUE_LENGTH];
		CMapWorld::FaceID_FaceListsToString( szSetValue, sizeof( szSetValue ), &m_Faces, NULL );
		eResult = pFile->WriteKeyValue( "sides", szSetValue );
	}

	if ( eResult == ChunkFile_Ok )
	{
		eResult = pFile->EndChunk();
	}

	return eResult;
}