csgo/cstrike15_src/hammer/DispShore.cpp

//========= Copyright � 1996-2004, Valve LLC, All rights reserved. ============
//
//
//=============================================================================

#include <stdafx.h>
#include "FaceEditSheet.h"
#include "MainFrm.h"
#include "GlobalFunctions.h"
#include "MapDisp.h"
#include "DispShore.h"
#include "UtlVector.h"
#include "mapdoc.h"
#include "mapworld.h"
#include "mapsolid.h"
#include "materialsystem/IMesh.h"
#include "Material.h"
#include "collisionutils.h"
#include "TextureSystem.h"
#include "mapoverlay.h"

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

IMPLEMENT_MAPCLASS( CMapOverlayTransition )

#define DISPSHORE_WIDTH_WORLD		25.0f
#define DISPSHORE_WIDTH_WATER		25.0f
#define DISPSHORE_VECTOR_EPS		0.1f
#define	DISPSHORE_SURF_LENGTH		120.0f

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Shoreline_t::Shoreline_t()
{
	m_nShorelineId = -1;
	m_aSegments.Purge();
	m_aOverlays.Purge();
	m_flLength = 0.0f;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Shoreline_t::~Shoreline_t()
{
	m_aSegments.Purge();
	m_aOverlays.Purge();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Shoreline_t::AddSegment( Vector &vecPoint0, Vector &vecPoint1, 
						      Vector &vecNormal, float flWaterZ, 
							  CMapFace *pWaterFace, EditDispHandle_t hDisp )
{
	// Check for duplicates!
	int nSegmentCount = m_aSegments.Count();
	int iSegment;
	for ( iSegment = 0; iSegment < nSegmentCount; ++iSegment )
	{
		if ( VectorsAreEqual( m_aSegments[iSegment].m_vecPoints[0], vecPoint0, DISPSHORE_VECTOR_EPS ) ) 
		{ 
			if ( VectorsAreEqual( m_aSegments[iSegment].m_vecPoints[1], vecPoint1, DISPSHORE_VECTOR_EPS ) ) 
				return;
		}

		if ( VectorsAreEqual( m_aSegments[iSegment].m_vecPoints[1], vecPoint0, DISPSHORE_VECTOR_EPS ) ) 
		{
			if ( VectorsAreEqual( m_aSegments[iSegment].m_vecPoints[0], vecPoint1, DISPSHORE_VECTOR_EPS ) )
				return;
		}
	}

	iSegment = m_aSegments.AddToTail();

	Vector vecEdge, vecCross;
	VectorSubtract( vecPoint1, vecPoint0, vecEdge );
	CrossProduct( vecNormal, vecEdge, vecCross );
	if ( vecCross.z >= 0.0f )
	{
		VectorCopy( vecPoint1, m_aSegments[iSegment].m_vecPoints[0] );
		VectorCopy( vecPoint0, m_aSegments[iSegment].m_vecPoints[1] );
	}
	else
	{
		VectorCopy( vecPoint0, m_aSegments[iSegment].m_vecPoints[0] );
		VectorCopy( vecPoint1, m_aSegments[iSegment].m_vecPoints[1] );
	}

	VectorCopy( vecNormal, m_aSegments[iSegment].m_vecNormals[0] );
	VectorCopy( vecNormal, m_aSegments[iSegment].m_vecNormals[1] );

	m_aSegments[iSegment].m_hDisp = hDisp;
	m_aSegments[iSegment].m_flWaterZ = flWaterZ;
	m_aSegments[iSegment].m_iStartPoint = 0;
	m_aSegments[iSegment].m_bTouch = false;
	m_aSegments[iSegment].m_bCreated = false;
	m_aSegments[iSegment].m_vecCenter.Init();

	m_aSegments[iSegment].m_WorldFace.m_bAdjWinding = false;	
	m_aSegments[iSegment].m_WaterFace.m_bAdjWinding = false;
	for ( int i = 0; i < 4; ++i )
	{
		m_aSegments[iSegment].m_WorldFace.m_vecPoints[i].Init();
		m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[i].Init();
		m_aSegments[iSegment].m_WorldFace.m_pFaces[i] = NULL;

		m_aSegments[iSegment].m_WaterFace.m_vecPoints[i].Init();
		m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[i].Init();
		m_aSegments[iSegment].m_WaterFace.m_pFaces[i] = NULL;
	}
}

//=============================================================================
//
// CDispShoreManager
//
class CDispShoreManager : public IDispShoreManager
{
public:

	CDispShoreManager();
	~CDispShoreManager();

	// Interface.
	bool		Init( void );
	void		Shutdown( void );

	int			GetShorelineCount( void );
	Shoreline_t *GetShoreline( int nShorelineId );
	void		AddShoreline( int nShorelineId );
	void		RemoveShoreline( int nShorelineId );
	void		BuildShoreline( int nShorelineId, CUtlVector<CMapFace*> &aFaces, CUtlVector<CMapFace*> &aWaterFaces );
       
	void		Draw( CRender3D *pRender );
	void		DebugDraw( CRender3D *pRender );

private:

	void BuildShorelineSegments( Shoreline_t *pShoreline, CUtlVector<CMapFace*> &aFaces, CUtlVector<CMapFace*> &aWaterFaces );
	void AverageShorelineNormals( Shoreline_t *pShoreline );
	void BuildShorelineOverlayPoints( Shoreline_t *pShoreline, CUtlVector<CMapFace*> &aWaterFaces );
	void BuildShorelineOverlayPoint( Shoreline_t *pShoreline, int iSegment, CUtlVector<CMapFace*> &aWaterFaces );
	bool TexcoordShoreline( Shoreline_t *pShoreline );
	void ShorelineLength( Shoreline_t *pShoreline );
	void GenerateTexCoord( Shoreline_t *pShoreline, int iSegment, float flLengthToSegment, bool bEnd );
	void BuildShorelineOverlays( Shoreline_t *pShoreline );
	void CreateOverlays( Shoreline_t *pShoreline, int iSegment );

	void DrawShorelines( int iShoreline );
	void DrawShorelineNormals( int iShoreline );
	void DrawShorelineOverlayPoints( CRender3D *pRender, int iShoreline );

	bool ConnectShorelineSegments( Shoreline_t *pShoreline );
	int	 FindShorelineStart( Shoreline_t *pShoreline );

	bool IsTouched( Shoreline_t *pShoreline, int iSegment )		{ return pShoreline->m_aSegments[iSegment].m_bTouch; }

private:

	CUtlVector<Shoreline_t>		m_aShorelines;

	// Displacement face and water face cache - for building.
	CUtlVector<CMapDisp*>		m_aDispCache;
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CDispShoreManager s_DispShoreManager;

IDispShoreManager *GetShoreManager( void )
{
	return &s_DispShoreManager;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CDispShoreManager::CDispShoreManager()
{
	m_aDispCache.Purge();
	m_aShorelines.Purge();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CDispShoreManager::~CDispShoreManager()
{
	m_aDispCache.Purge();
	m_aShorelines.Purge();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CDispShoreManager::Init( void )
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::Shutdown( void )
{
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int	CDispShoreManager::GetShorelineCount( void )
{
	return m_aShorelines.Count();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Shoreline_t *CDispShoreManager::GetShoreline( int nShorelineId )
{
	int nShorelineCount = m_aShorelines.Count();
	for ( int iShoreline = 0; iShoreline < nShorelineCount; ++iShoreline )
	{
		if ( m_aShorelines[iShoreline].m_nShorelineId == nShorelineId )
			return &m_aShorelines[iShoreline];
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::AddShoreline( int nShorelineId )
{
	// Check to see if the id is already taken, if so remove it and re-add it.
	RemoveShoreline( nShorelineId );

	int iShoreline = m_aShorelines.AddToTail();
	m_aShorelines[iShoreline].m_nShorelineId = nShorelineId;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::RemoveShoreline( int nShorelineId )
{
	int nShorelineCount = m_aShorelines.Count();
	for ( int iShoreline = ( nShorelineCount - 1 ); iShoreline >= 0; --iShoreline )
	{
		if ( m_aShorelines[iShoreline].m_nShorelineId == nShorelineId )
		{
			m_aShorelines.Remove( iShoreline );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::BuildShoreline( int nShorelineId, CUtlVector<CMapFace*> &aFaces, CUtlVector<CMapFace*> &aWaterFaces )
{
	// Verify faces to build a shoreline.
	if ( ( aFaces.Count() == 0 ) ||( aWaterFaces.Count() == 0 ) )
		return;

	Shoreline_t *pShoreline = GetShoreline( nShorelineId );
	if ( pShoreline )
	{
		BuildShorelineSegments( pShoreline, aFaces, aWaterFaces );
		AverageShorelineNormals( pShoreline );
		BuildShorelineOverlayPoints( pShoreline, aWaterFaces );
		TexcoordShoreline( pShoreline );
		BuildShorelineOverlays( pShoreline );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::BuildShorelineSegments( Shoreline_t *pShoreline, CUtlVector<CMapFace*> &aFaces, CUtlVector<CMapFace*> &aWaterFaces )
{
	int nWaterFaceCount = aWaterFaces.Count();
	for ( int iWaterFace = 0; iWaterFace < nWaterFaceCount; ++iWaterFace )
	{
		int nFaceCount = aFaces.Count();
		for ( int iFace = 0; iFace < nFaceCount; ++iFace )
		{	
			CMapFace *pFace = aFaces.Element( iFace );
			if ( pFace )
			{
				if ( !pFace->HasDisp() )
				{
					// Ignore for now!
				}
				else
				{
					// Displacement.
					CMapDisp *pDisp = EditDispMgr()->GetDisp( pFace->GetDisp() );
					if ( pDisp )
					{
						pDisp->CreateShoreOverlays( aWaterFaces[iWaterFace], pShoreline );
					}
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::AverageShorelineNormals( Shoreline_t *pShoreline )
{
	int nSegmentCount = pShoreline->m_aSegments.Count();
	if ( nSegmentCount == 0 )
		return;

	for ( int iSegment1 = 0; iSegment1 < nSegmentCount; ++iSegment1 )
	{
		for ( int iSegment2 = iSegment1 + 1; iSegment2 < nSegmentCount; ++iSegment2 )
		{
			int iPoint1 = -1;
			int iPoint2 = -1;

			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment1].m_vecPoints[0], 
				                  pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) )
			{
				iPoint1 = 0;
				iPoint2 = 0;
			}

			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment1].m_vecPoints[0], 
				                  pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) )
			{
				iPoint1 = 0;
				iPoint2 = 1;
			}

			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment1].m_vecPoints[1], 
				                  pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) )
			{
				iPoint1 = 1;
				iPoint2 = 0;
			}

			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment1].m_vecPoints[1], 
				                  pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) )
			{
				iPoint1 = 1;
				iPoint2 = 1;
			}

			if ( ( iPoint1 != -1 ) && ( iPoint2 != -1 ) )
			{
				pShoreline->m_aSegments[iSegment2].m_vecPoints[iPoint2] = pShoreline->m_aSegments[iSegment1].m_vecPoints[iPoint1];
				Vector vecNormal = pShoreline->m_aSegments[iSegment1].m_vecNormals[iPoint1] + pShoreline->m_aSegments[iSegment2].m_vecNormals[iPoint2];
				VectorNormalize( vecNormal );
				pShoreline->m_aSegments[iSegment1].m_vecNormals[iPoint1] = vecNormal;
				pShoreline->m_aSegments[iSegment2].m_vecNormals[iPoint2] = vecNormal;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::BuildShorelineOverlayPoints( Shoreline_t *pShoreline, CUtlVector<CMapFace*> &aWaterFaces )
{
	int nSegmentCount = pShoreline->m_aSegments.Count();
	if ( nSegmentCount == 0 )
		return;

	for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
	{
		BuildShorelineOverlayPoint( pShoreline, iSegment, aWaterFaces );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::BuildShorelineOverlayPoint( Shoreline_t *pShoreline, int iSegment, CUtlVector<CMapFace*> &aWaterFaces )
{
	// Get the displacement manager and segment displacement.
	CMapDisp *pDisp = EditDispMgr()->GetDisp( pShoreline->m_aSegments[iSegment].m_hDisp );
	if ( !pDisp )
		return;

	IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
	if( !pDispMgr )
		return;

	// Build a bounding box from the world points.
	Vector vecPoints[4];	
	vecPoints[0] = pShoreline->m_aSegments[iSegment].m_vecPoints[0];
	vecPoints[3] = pShoreline->m_aSegments[iSegment].m_vecPoints[1];
	vecPoints[1] = vecPoints[0] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0] * pShoreline->m_ShoreData.m_flWidths[0] );
	vecPoints[2] = vecPoints[3] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1] * pShoreline->m_ShoreData.m_flWidths[0] );

	Vector vecWorldMin = vecPoints[0]; 
	Vector vecWorldMax = vecPoints[0];
	for ( int iPoint = 1; iPoint < 4; ++iPoint )
	{
		for ( int iAxis = 0; iAxis < 3; ++iAxis )
		{
			if ( vecPoints[iPoint][iAxis] < vecWorldMin[iAxis] )
			{
				vecWorldMin[iAxis] = vecPoints[iPoint][iAxis];
			}

			if ( vecPoints[iPoint][iAxis] > vecWorldMax[iAxis] )
			{
				vecWorldMax[iAxis] = vecPoints[iPoint][iAxis];
			}
		}
	}

	for ( int iAxis = 0; iAxis < 2; ++iAxis )
	{
		vecWorldMin[iAxis] -= 1.0f;
		vecWorldMax[iAxis] += 1.0f;
	}
	vecWorldMin.z -= 150.0f;
	vecWorldMax.z += 150.0f;

	// Build a list of displacements that intersect the bounding box.
	CUtlVector<CMapDisp*> m_aDispList;
	m_aDispList.Purge();

	Vector vecDispMin, vecDispMax;
	int nDispCount = pDispMgr->WorldCount();
	for ( int iDisp = 0; iDisp < nDispCount; ++iDisp )
	{
		CMapDisp *pCurDisp = pDispMgr->GetFromWorld( iDisp );
		if ( !pCurDisp )
			continue;

		if ( pCurDisp == pDisp )
			continue;

		// Check for intersections.
		pCurDisp->GetBoundingBox( vecDispMin, vecDispMax );
		if ( IsBoxIntersectingBox( vecWorldMin, vecWorldMax, vecDispMin, vecDispMax ) )
		{
			m_aDispList.AddToTail( pCurDisp );
		}
	}

	// World points.
	CMapFace *pFace = static_cast<CMapFace*>( pDisp->GetParent() );
	for ( int iFace = 0; iFace < 4; ++iFace )
	{
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[iFace] = pFace;
	}

	pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[0] = pShoreline->m_aSegments[iSegment].m_vecPoints[0];
	pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[3] = pShoreline->m_aSegments[iSegment].m_vecPoints[1];

	Vector vecPoint = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[0] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0] * pShoreline->m_ShoreData.m_flWidths[0] );
	Vector vecStart( vecPoint.x, vecPoint.y, vecPoint.z + 150.0f );
	Vector vecEnd( vecPoint.x, vecPoint.y, vecPoint.z - 150.0f );		
	Vector vecHit, vecHitNormal;
	CMapFace *pHitFace = pFace;
	if ( !pDisp->TraceLine( vecHit, vecHitNormal, vecStart, vecEnd ) )
	{
		nDispCount = m_aDispList.Count();
		int iDisp;
		for ( iDisp = 0; iDisp < nDispCount; ++iDisp )
		{
			if ( m_aDispList[iDisp]->TraceLine( vecHit, vecHitNormal, vecStart, vecEnd ) )
			{
				pHitFace = ( CMapFace* )m_aDispList[iDisp]->GetParent();
				break;
			}
		}

		if ( iDisp == nDispCount )
		{
			pDisp->TraceLineSnapTo( vecHit, vecHitNormal, vecStart, vecEnd );
		}
	}
	pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[1] = vecHit;
	pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[1] = pHitFace;
	
	vecPoint = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[3] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1] * pShoreline->m_ShoreData.m_flWidths[0] );
	vecStart.Init( vecPoint.x, vecPoint.y, vecPoint.z + 150.0f );
	vecEnd.Init( vecPoint.x, vecPoint.y, vecPoint.z - 150.0f );
	pHitFace = pFace;
	if ( !pDisp->TraceLine( vecHit, vecHitNormal, vecStart, vecEnd ) )
	{
		nDispCount = m_aDispList.Count();
		int iDisp;
		for ( iDisp = 0; iDisp < nDispCount; ++iDisp )
		{
			if ( m_aDispList[iDisp]->TraceLine( vecHit, vecHitNormal, vecStart, vecEnd ) )
			{
				pHitFace = ( CMapFace* )m_aDispList[iDisp]->GetParent();
				break;
			}
		}

		if ( iDisp == nDispCount )
		{
			pDisp->TraceLineSnapTo( vecHit, vecHitNormal, vecStart, vecEnd );
		}
	}
	pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[2] = vecHit;
	pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[2] = pHitFace;
	
	// Water points.
	pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[0] = pShoreline->m_aSegments[iSegment].m_vecPoints[0] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0] * -pShoreline->m_ShoreData.m_flWidths[1] );
	pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[1] = pShoreline->m_aSegments[iSegment].m_vecPoints[0];
	pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[2] = pShoreline->m_aSegments[iSegment].m_vecPoints[1];
	pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[3] = pShoreline->m_aSegments[iSegment].m_vecPoints[1] + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1] * -pShoreline->m_ShoreData.m_flWidths[1] );
	int nWaterFaceCount = aWaterFaces.Count();
	for ( int iWaterFace = 0; iWaterFace < nWaterFaceCount; ++iWaterFace )
	{
		CMapFace *pWaterFace = aWaterFaces.Element( iWaterFace );
		if ( pWaterFace )
		{
			for ( int iWaterPoint = 0; iWaterPoint < 4; ++iWaterPoint )
			{
				vecPoint = pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[iWaterPoint];
				vecStart.Init( vecPoint.x, vecPoint.y, vecPoint.z + 150.0f );
				vecEnd.Init( vecPoint.x, vecPoint.y, vecPoint.z - 150.0f );
				if ( pWaterFace->TraceLineInside( vecHit, vecHitNormal, vecStart, vecEnd ) )
				{
					pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint] = pWaterFace;
				}
			}
		}
	}

	// Water face clean up!
	int nNoFaceCount = false;
	for ( int iWaterPoint = 0; iWaterPoint < 4; ++iWaterPoint )
	{
		if ( !pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint] )
		{
			++nNoFaceCount;
		}
	}
	if ( ( nNoFaceCount > 0 ) && ( nNoFaceCount < 4 ) )
	{
		// Find a valid face.
		CMapFace *pWaterFace = NULL;
		for ( int iWaterPoint = 0; iWaterPoint < 4; ++iWaterPoint )
		{
			if ( pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint] )
			{
				pWaterFace = pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint];
				break;
			}
		}
	
		for ( int iWaterPoint = 0; iWaterPoint < 4; ++iWaterPoint )
		{
			if ( !pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint] )
			{
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iWaterPoint] = pWaterFace;
			}
		}
	}	

	// Center.
	pShoreline->m_aSegments[iSegment].m_vecCenter = ( pShoreline->m_aSegments[iSegment].m_vecPoints[0] + pShoreline->m_aSegments[iSegment].m_vecPoints[1] ) * 0.5f;

	// Check winding.
	Vector vecEdge0, vecEdge1, vecCross;

	pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding = false;
	VectorSubtract( pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[1], pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[0], vecEdge0 );
	VectorSubtract( pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[2], pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[0], vecEdge1 );
	VectorNormalize( vecEdge0 );
	VectorNormalize( vecEdge1 );
	CrossProduct( vecEdge1, vecEdge0, vecCross );
	if ( vecCross.z < 0.0f )
	{
		// Adjust winding.
		Vector vecTmp = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[1];
		CMapFace *pTmpFace = pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[1];
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[1] = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[3];
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[1] = pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[3];
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[3] = vecTmp;
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[3] = pTmpFace;
		pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding = true;
	}

	pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding = false;
	VectorSubtract( pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[1], pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[0], vecEdge0 );
	VectorSubtract( pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[2], pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[0], vecEdge1 );
	VectorNormalize( vecEdge0 );
	VectorNormalize( vecEdge1 );
	CrossProduct( vecEdge1, vecEdge0, vecCross );
	if ( vecCross.z < 0.0f )
	{
		// Adjust winding.
		Vector vecTmp = pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[1];
		CMapFace *pTmpFace = pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[1];
		pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[1] = pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[3];
		pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[1] = pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[3];
		pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[3] = vecTmp;
		pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[3] = pTmpFace;
		pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding = true;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CDispShoreManager::TexcoordShoreline( Shoreline_t *pShoreline )
{
	int nSegmentCount = pShoreline->m_aSegments.Count();
	if ( nSegmentCount == 0 )
		return false;

	// Conncect the shoreline segments to produce a continuous shoreline.
	if ( !ConnectShorelineSegments( pShoreline ) )
		return false;

	ShorelineLength( pShoreline );

	float flLengthToSegment = 0.0f;
	int nSortedSegmentCount = pShoreline->m_aSortedSegments.Count();
	for ( int iSegment = 0; iSegment < nSortedSegmentCount; ++iSegment )
	{
		int iSortSegment = pShoreline->m_aSortedSegments[iSegment];

		GenerateTexCoord( pShoreline, iSortSegment, flLengthToSegment, false );

		Vector vecEdge;
		VectorSubtract( pShoreline->m_aSegments[iSortSegment].m_vecPoints[1], pShoreline->m_aSegments[iSortSegment].m_vecPoints[0], vecEdge );
		flLengthToSegment += vecEdge.Length();

		GenerateTexCoord( pShoreline, iSortSegment, flLengthToSegment, true );
	}	

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CDispShoreManager::ConnectShorelineSegments( Shoreline_t *pShoreline )
{
	// Reset/recreate the shoreline sorted segment list.
	pShoreline->m_aSortedSegments.Purge();

	int iSegment = FindShorelineStart( pShoreline );
	if ( iSegment == -1 )
	{
		iSegment = 0;
	}

	int nSegmentCount = pShoreline->m_aSegments.Count();
	while ( iSegment != -1 )
	{
		int iSegment2;
		for ( iSegment2 = 0; iSegment2 < nSegmentCount; ++iSegment2 )
		{
			if ( iSegment2 == iSegment )
				continue;

			bool bIsTouching0 = false;
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[0], pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) ) { bIsTouching0 = true; }
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[1], pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) ) { bIsTouching0 = true; }
			bool bIsTouching1 = false;
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[0], pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) ) { bIsTouching1 = true; }
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[1], pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) ) { bIsTouching1 = true; }

			if ( ( bIsTouching0 || bIsTouching1 ) && !IsTouched( pShoreline, iSegment2 ) )
			{
				pShoreline->m_aSegments[iSegment2].m_iStartPoint = 0;
				if ( bIsTouching1 )
				{
					pShoreline->m_aSegments[iSegment2].m_iStartPoint = 1;
				}

				pShoreline->m_aSortedSegments.AddToTail( iSegment2 );
				pShoreline->m_aSegments[iSegment2].m_bTouch = true;
				break;
			}
		}

		if ( iSegment2 != nSegmentCount )
		{
			iSegment = iSegment2;
		}
		else
		{
			iSegment = -1;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CDispShoreManager::FindShorelineStart( Shoreline_t *pShoreline )
{
	// Find a segment that doesn't have any (fewest) matching point data.
	int nSegmentCount = pShoreline->m_aSegments.Count();
	for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
	{
		int nTouchCount = 0;
		int iStartPoint = -1;
		for ( int iSegment2 = 0; iSegment2 < nSegmentCount; ++iSegment2 )
		{
			if ( iSegment == iSegment2 )
				continue;

			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[0], pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) ) 
			{ 
				++nTouchCount; 
				iStartPoint = 1;
			}
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[0], pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) ) 
			{ 
				++nTouchCount;
				iStartPoint = 1;
			}
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[1], pShoreline->m_aSegments[iSegment2].m_vecPoints[0], DISPSHORE_VECTOR_EPS ) ) 
			{ 
				++nTouchCount;
				iStartPoint = 0;
			}
			if ( VectorsAreEqual( pShoreline->m_aSegments[iSegment].m_vecPoints[1], pShoreline->m_aSegments[iSegment2].m_vecPoints[1], DISPSHORE_VECTOR_EPS ) ) 
			{ 
				++nTouchCount; 
				iStartPoint = 0;
			}
		}

		if ( nTouchCount == 1 )
		{
			pShoreline->m_aSegments[iSegment].m_iStartPoint = iStartPoint;
			pShoreline->m_aSortedSegments.AddToTail( iSegment );
			pShoreline->m_aSegments[iSegment].m_bTouch = true;
			return iSegment;
		}
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::ShorelineLength( Shoreline_t *pShoreline )
{
	float flLength = 0.0f;
	int nSegmentCount = pShoreline->m_aSegments.Count();
	for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
	{
		Vector vecEdge;
		VectorSubtract( pShoreline->m_aSegments[iSegment].m_vecPoints[1], pShoreline->m_aSegments[iSegment].m_vecPoints[0], vecEdge );
		flLength += vecEdge.Length();
	}

	pShoreline->m_flLength = flLength;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::GenerateTexCoord( Shoreline_t *pShoreline, int iSegment, float flLengthToSegment, bool bEnd )
{
	float flValue = pShoreline->m_ShoreData.m_vecLengthTexcoord[1] - pShoreline->m_ShoreData.m_vecLengthTexcoord[0];

	if ( pShoreline->m_aSegments[iSegment].m_iStartPoint == 0 )
	{
		if ( !bEnd )
		{
			float flRatio = flLengthToSegment / pShoreline->m_flLength;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[0].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[0].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[0].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[0].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			
			if ( pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding )
			{
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			}
			else
			{
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			}

			if ( pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding )
			{
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
			else
			{
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
		}
		else
		{
			float flRatio = flLengthToSegment / pShoreline->m_flLength;

			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[2].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[2].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[2].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[2].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			
			if ( pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding )
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
			else
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}

			if ( pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding )
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			}
			else
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			}
		}
	}
	else
	{
		if ( !bEnd )
		{
			float flRatio = flLengthToSegment / pShoreline->m_flLength;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[2].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[2].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[2].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[2].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			
			if ( pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding )
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
			else
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}

			if ( pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding )
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			}
			else
			{
				flRatio = flLengthToSegment / pShoreline->m_flLength;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			}
		}
		else
		{
			float flRatio = flLengthToSegment / pShoreline->m_flLength;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[0].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[0].x = flValue * flRatio;
			pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[0].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[0].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[0];
			
			if ( pShoreline->m_aSegments[iSegment].m_WorldFace.m_bAdjWinding )
			{
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			}
			else
			{
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1];
			}

			if ( pShoreline->m_aSegments[iSegment].m_WaterFace.m_bAdjWinding )
			{
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[3].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
			else
			{
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].x = flValue * flRatio;
				pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords[1].y = pShoreline->m_ShoreData.m_vecWidthTexcoord[1] * 0.5f;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::BuildShorelineOverlays( Shoreline_t *pShoreline )
{	
	// Reset the list.
	if ( pShoreline->m_aOverlays.Count() != 0 )
	{
		pShoreline->m_aOverlays.Purge();
	}

	int nSegmentCount = pShoreline->m_aSegments.Count();
	if ( nSegmentCount == 0 )
		return;

	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;
	
	for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
	{
		CMapDisp *pDisp = EditDispMgr()->GetDisp( pShoreline->m_aSegments[iSegment].m_hDisp );
		if ( !pDisp )
			continue;

		CMapFace *pFace = ( CMapFace* )pDisp->GetParent();
		if ( !pFace )
			continue;

		CreateOverlays( pShoreline, iSegment );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::CreateOverlays( Shoreline_t *pShoreline, int iSegment )
{
	// Create the face list than this overlay will act upon.
	CUtlVector<CMapFace*> aWorldFaces;
	CUtlVector<CMapFace*> aWaterFaces;
	for ( int iFace = 0; iFace < 4; ++iFace )
	{
		if ( !pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[iFace] ||
			 !pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iFace] )
			return;

		// World
		if ( aWorldFaces.Find( pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[iFace] ) == -1 )
		{
			aWorldFaces.AddToTail( pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[iFace] );
		}

		// Water
		if ( aWaterFaces.Find( pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iFace] ) == -1 )
		{
			aWaterFaces.AddToTail( pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[iFace] );
		}
	}

	// Create and add data to the world overlay.
	int iOverlay = pShoreline->m_aOverlays.AddToTail();
	CMapOverlay *pOverlay = &pShoreline->m_aOverlays[iOverlay];

	pOverlay->SetOverlayType( OVERLAY_TYPE_SHORE );

	pOverlay->Basis_Init( aWorldFaces[0] );
	pOverlay->Handles_Init( aWorldFaces[0] );
	pOverlay->SideList_Init( aWorldFaces[0] );

	int nFaceCount = aWorldFaces.Count();
	for ( int iFace = 1; iFace < nFaceCount; ++iFace )
	{
		pOverlay->SideList_AddFace( aWorldFaces[iFace] );
	}

	pOverlay->SetLoaded( true );

	pOverlay->HandleMoveTo( 0, pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[0], pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[0] );
	pOverlay->HandleMoveTo( 1, pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[1], pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[1] );
	pOverlay->HandleMoveTo( 2, pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[2], pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[2] );
	pOverlay->HandleMoveTo( 3, pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[3], pShoreline->m_aSegments[iSegment].m_WorldFace.m_pFaces[3] );

	if ( !pShoreline->m_ShoreData.m_pTexture )
	{
		pOverlay->SetMaterial( "decals/decal_signroute004b" );
	}
	else
	{
		pOverlay->SetMaterial( pShoreline->m_ShoreData.m_pTexture );
	}
	pOverlay->SetTexCoords( pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecTexCoords );

	pOverlay->CalcBounds( true );

	pOverlay->DoClip();
	pOverlay->PostUpdate( Notify_Changed );

	// Create and add data to the water overlay.
	iOverlay = pShoreline->m_aOverlays.AddToTail();
	pOverlay = &pShoreline->m_aOverlays[iOverlay];

	pOverlay->SetOverlayType( OVERLAY_TYPE_SHORE );

	pOverlay->Basis_Init( aWaterFaces[0] );
	pOverlay->Handles_Init( aWaterFaces[0] );
	pOverlay->SideList_Init( aWaterFaces[0] );

	nFaceCount = aWaterFaces.Count();
	for ( int iFace = 1; iFace < nFaceCount; ++iFace )
	{
		pOverlay->SideList_AddFace( aWaterFaces[iFace] );
	}

	pOverlay->SetLoaded( true );

	pOverlay->HandleMoveTo( 0, pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[0], pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[0] );
	pOverlay->HandleMoveTo( 1, pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[1], pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[1] );
	pOverlay->HandleMoveTo( 2, pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[2], pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[2] );
	pOverlay->HandleMoveTo( 3, pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[3], pShoreline->m_aSegments[iSegment].m_WaterFace.m_pFaces[3] );

	if ( !pShoreline->m_ShoreData.m_pTexture )
	{
		pOverlay->SetMaterial( "decals/decal_signroute004b" );
	}
	else
	{
		pOverlay->SetMaterial( pShoreline->m_ShoreData.m_pTexture );
	}
	pOverlay->SetTexCoords( pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecTexCoords );

	pOverlay->SetOverlayType( OVERLAY_TYPE_SHORE );

	pOverlay->CalcBounds( true );

	pOverlay->DoClip();
	pOverlay->PostUpdate( Notify_Changed );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::Draw( CRender3D *pRender )
{
	int nShoreCount = m_aShorelines.Count();
	for ( int iShore = 0; iShore < nShoreCount; ++iShore )
	{
		Shoreline_t *pShoreline = &m_aShorelines[iShore];
		if ( pShoreline )
		{
			int nOverlayCount = pShoreline->m_aOverlays.Count();
			for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay )
			{
				CMapOverlay *pOverlay = &pShoreline->m_aOverlays[iOverlay];
				if ( pOverlay )
				{
					pOverlay->Render3D( pRender );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::DebugDraw( CRender3D *pRender )
{
	pRender->SetRenderMode( RENDER_MODE_WIREFRAME );

	int nShorelineCount = GetShorelineCount();
	for ( int iShoreline = 0; iShoreline < nShorelineCount; ++iShoreline )
	{
		DrawShorelines( iShoreline );
		DrawShorelineNormals( iShoreline );
		DrawShorelineOverlayPoints( pRender, iShoreline );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::DrawShorelines( int iShoreline )
{
	Shoreline_t *pShoreline = &m_aShorelines[iShoreline];
	if ( pShoreline )
	{
		int nSegmentCount = pShoreline->m_aSegments.Count();
		if ( nSegmentCount == 0 )
			return;

		CMeshBuilder meshBuilder;
		CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
		IMesh* pMesh = pRenderContext->GetDynamicMesh();
		meshBuilder.Begin( pMesh, MATERIAL_LINES, ( nSegmentCount * 2 ) );

		for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
		{
			meshBuilder.Color3f( 1.0f, 0.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[0].x, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].y, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].z + 50.0f );
			meshBuilder.AdvanceVertex();
			
			meshBuilder.Color3f( 1.0f, 0.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[1].x, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].y, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].z + 50.0f );
			meshBuilder.AdvanceVertex();
		}

		meshBuilder.End();
		pMesh->Draw();
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::DrawShorelineNormals( int iShoreline )
{
#define DISPSHORE_NORMAL_SCALE 25.0f

	Shoreline_t *pShoreline = &m_aShorelines[iShoreline];
	if ( pShoreline )
	{
		int nSegmentCount = pShoreline->m_aSegments.Count();
		if ( nSegmentCount == 0 )
			return;

		CMeshBuilder meshBuilder;
		CMatRenderContextPtr pRenderContext( materials );
		IMesh* pMesh = pRenderContext->GetDynamicMesh();
		meshBuilder.Begin( pMesh, MATERIAL_LINES, ( nSegmentCount * 4 ) );

		for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
		{
			// Normal for vertex 0.
			meshBuilder.Color3f( 1.0f, 1.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[0].x, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].y, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].z + 50.0f );
			meshBuilder.AdvanceVertex();
			
			meshBuilder.Color3f( 1.0f, 1.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[0].x + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0].x * DISPSHORE_NORMAL_SCALE ), 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].y + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0].y * DISPSHORE_NORMAL_SCALE ), 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[0].z + 50.0f + ( pShoreline->m_aSegments[iSegment].m_vecNormals[0].z * DISPSHORE_NORMAL_SCALE ) );
			meshBuilder.AdvanceVertex();
			
			// Normal for vertex 1.
			meshBuilder.Color3f( 1.0f, 1.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[1].x, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].y, 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].z + 50.0f );
			meshBuilder.AdvanceVertex();
			
			meshBuilder.Color3f( 1.0f, 1.0f, 0.0f );
			meshBuilder.Position3f( pShoreline->m_aSegments[iSegment].m_vecPoints[1].x + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1].x * DISPSHORE_NORMAL_SCALE ), 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].y + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1].y * DISPSHORE_NORMAL_SCALE ), 
				                    pShoreline->m_aSegments[iSegment].m_vecPoints[1].z + 50.0f + ( pShoreline->m_aSegments[iSegment].m_vecNormals[1].z * DISPSHORE_NORMAL_SCALE ) );
			meshBuilder.AdvanceVertex();
		}

		meshBuilder.End();
		pMesh->Draw();
	}

#undef DISPSHORE_NORMAL_SCALE
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDispShoreManager::DrawShorelineOverlayPoints( CRender3D *pRender, int iShoreline )
{
#define DISPSHORE_BOX_SIZE	5.0f

	Shoreline_t *pShoreline = &m_aShorelines[iShoreline];
	if ( pShoreline )
	{
		int nSegmentCount = pShoreline->m_aSegments.Count();
		if ( nSegmentCount == 0 )
			return;
		
		Vector vecWorldMin, vecWorldMax;
		for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
		{
			for ( int iWorldPoint = 0; iWorldPoint < 4; ++iWorldPoint )
			{
				vecWorldMin = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[iWorldPoint];
				vecWorldMax = pShoreline->m_aSegments[iSegment].m_WorldFace.m_vecPoints[iWorldPoint];
				for ( int iAxis = 0; iAxis < 3; ++iAxis )
				{
					vecWorldMin[iAxis] -= DISPSHORE_BOX_SIZE;
					vecWorldMax[iAxis] += DISPSHORE_BOX_SIZE;
				}
				
				pRender->RenderBox( vecWorldMin, vecWorldMax, 255, 0, 0, SELECT_NONE );
			}
			
			for ( int iWorldPoint = 0; iWorldPoint < 4; ++iWorldPoint )
			{
				vecWorldMin = pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[iWorldPoint];
				vecWorldMax = pShoreline->m_aSegments[iSegment].m_WaterFace.m_vecPoints[iWorldPoint];
				for ( int iAxis = 0; iAxis < 3; ++iAxis )
				{
					vecWorldMin[iAxis] -= DISPSHORE_BOX_SIZE;
					vecWorldMax[iAxis] += DISPSHORE_BOX_SIZE;
				}
				
				pRender->RenderBox( vecWorldMin, vecWorldMax, 0, 0, 255, SELECT_NONE );
			}
		}
	}

#undef DISPSHORE_BOX_SIZE
}