Fix line endings. WHAMMY.

1 files changed, 487 insertions, 487 deletions

diff --git a/mp/src/utils/vbsp/overlay.cpp b/mp/src/utils/vbsp/overlay.cpp
index fcd2e924..edceba9a 100644
--- a/mp/src/utils/vbsp/overlay.cpp
+++ b/mp/src/utils/vbsp/overlay.cpp
@@ -1,487 +1,487 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-// $NoKeywords: $

-//=============================================================================//

-

-#include "vbsp.h"

-#include "disp_vbsp.h"

-#include "builddisp.h"

-#include "mathlib/vmatrix.h"

-

-void Overlay_BuildBasisOrigin( doverlay_t *pOverlay );

-

-// Overlay list.

-CUtlVector<mapoverlay_t> g_aMapOverlays;

-CUtlVector<mapoverlay_t> g_aMapWaterOverlays;

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-int Overlay_GetFromEntity( entity_t *pMapEnt )

-{

-	int iAccessorID = -1;

-

-	// Allocate the new overlay.

-	int iOverlay = g_aMapOverlays.AddToTail();

-	mapoverlay_t *pMapOverlay = &g_aMapOverlays[iOverlay];

-

-	// Get the overlay data.

-	pMapOverlay->nId = g_aMapOverlays.Count() - 1;

-

-	if ( ValueForKey( pMapEnt, "targetname" )[ 0 ] != '\0' )

-	{

-		// Overlay has a name, remember it's ID for accessing

-		iAccessorID = pMapOverlay->nId;

-	}

-

-	pMapOverlay->flU[0] = FloatForKey( pMapEnt, "StartU" );

-	pMapOverlay->flU[1] = FloatForKey( pMapEnt, "EndU" );

-	pMapOverlay->flV[0] = FloatForKey( pMapEnt, "StartV" );

-	pMapOverlay->flV[1] = FloatForKey( pMapEnt, "EndV" );

-

-	pMapOverlay->flFadeDistMinSq = FloatForKey( pMapEnt, "fademindist" );

-	if ( pMapOverlay->flFadeDistMinSq > 0 )

-	{

-		pMapOverlay->flFadeDistMinSq *= pMapOverlay->flFadeDistMinSq;

-	}

-

-	pMapOverlay->flFadeDistMaxSq = FloatForKey( pMapEnt, "fademaxdist" );

-	if ( pMapOverlay->flFadeDistMaxSq > 0 )

-	{

-		pMapOverlay->flFadeDistMaxSq *= pMapOverlay->flFadeDistMaxSq;

-	}

-

-	GetVectorForKey( pMapEnt, "BasisOrigin", pMapOverlay->vecOrigin );

-

-	pMapOverlay->m_nRenderOrder = IntForKey( pMapEnt, "RenderOrder" );

-	if ( pMapOverlay->m_nRenderOrder < 0 || pMapOverlay->m_nRenderOrder >= OVERLAY_NUM_RENDER_ORDERS )

-		Error( "Overlay (%s) at %f %f %f has invalid render order (%d).\n", ValueForKey( pMapEnt, "material" ),

-				pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z,

-				pMapOverlay->m_nRenderOrder );

-

-	GetVectorForKey( pMapEnt, "uv0", pMapOverlay->vecUVPoints[0] );

-	GetVectorForKey( pMapEnt, "uv1", pMapOverlay->vecUVPoints[1] );

-	GetVectorForKey( pMapEnt, "uv2", pMapOverlay->vecUVPoints[2] );

-	GetVectorForKey( pMapEnt, "uv3", pMapOverlay->vecUVPoints[3] );

-

-	GetVectorForKey( pMapEnt, "BasisU", pMapOverlay->vecBasis[0] );

-	GetVectorForKey( pMapEnt, "BasisV", pMapOverlay->vecBasis[1] );

-	GetVectorForKey( pMapEnt, "BasisNormal", pMapOverlay->vecBasis[2] );

-

-	const char *pMaterialName = ValueForKey( pMapEnt, "material" );

-	Assert( strlen( pMaterialName ) < OVERLAY_MAP_STRLEN );

-	if ( strlen( pMaterialName ) >= OVERLAY_MAP_STRLEN )

-	{

-		Error( "Overlay Material Name (%s) too long! > OVERLAY_MAP_STRLEN (%d)", pMaterialName, OVERLAY_MAP_STRLEN );

-		return -1;

-	}

-	strcpy( pMapOverlay->szMaterialName, pMaterialName );	

-

-	// Convert the sidelist to side id(s).

-	const char *pSideList = ValueForKey( pMapEnt, "sides" );

-	char *pTmpList = ( char* )_alloca( strlen( pSideList ) + 1 );

-	strcpy( pTmpList, pSideList );

-	const char *pScan = strtok( pTmpList, " " );

-	if ( !pScan )

-		return iAccessorID;

-

-	pMapOverlay->aSideList.Purge();

-	pMapOverlay->aFaceList.Purge();

-

-	do

-	{

-		int nSideId;

-		if ( sscanf( pScan, "%d", &nSideId ) == 1 )

-		{

-			pMapOverlay->aSideList.AddToTail( nSideId );

-		}

-	} while ( ( pScan = strtok( NULL, " " ) ) );

-

-	return iAccessorID;

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-side_t *GetSide( int nSideId )

-{

-	for( int iSide = 0; iSide < g_LoadingMap->nummapbrushsides; ++iSide )

-	{

-		if ( g_LoadingMap->brushsides[iSide].id == nSideId )

-			return &g_LoadingMap->brushsides[iSide];

-	}

-

-	return NULL;

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void Overlay_UpdateSideLists( int StartIndex )

-{

-	int nMapOverlayCount = g_aMapOverlays.Count();

-	for( int iMapOverlay = StartIndex; iMapOverlay < nMapOverlayCount; ++iMapOverlay )

-	{

-		mapoverlay_t *pMapOverlay = &g_aMapOverlays.Element( iMapOverlay );

-		if ( pMapOverlay )

-		{

-			int nSideCount = pMapOverlay->aSideList.Count();

-			for( int iSide = 0; iSide < nSideCount; ++iSide )

-			{

-				side_t *pSide = GetSide( pMapOverlay->aSideList[iSide] );

-				if ( pSide )

-				{

-					if ( pSide->aOverlayIds.Find( pMapOverlay->nId ) == -1 )

-					{

-						pSide->aOverlayIds.AddToTail( pMapOverlay->nId );

-					}

-				}

-			}

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void OverlayTransition_UpdateSideLists( int StartIndex )

-{

-	int nOverlayCount = g_aMapWaterOverlays.Count();

-	for( int iOverlay = StartIndex; iOverlay < nOverlayCount; ++iOverlay )

-	{

-		mapoverlay_t *pOverlay = &g_aMapWaterOverlays.Element( iOverlay );

-		if ( pOverlay )

-		{

-			int nSideCount = pOverlay->aSideList.Count();

-			for( int iSide = 0; iSide < nSideCount; ++iSide )

-			{

-				side_t *pSide = GetSide( pOverlay->aSideList[iSide] );

-				if ( pSide )

-				{

-					if ( pSide->aWaterOverlayIds.Find( pOverlay->nId ) == -1 )

-					{

-						pSide->aWaterOverlayIds.AddToTail( pOverlay->nId );

-					}

-				}

-			}

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void Overlay_AddFaceToLists( int iFace, side_t *pSide )

-{

-	int nOverlayIdCount = pSide->aOverlayIds.Count();

-	for( int iOverlayId = 0; iOverlayId < nOverlayIdCount; ++iOverlayId )

-	{

-		mapoverlay_t *pMapOverlay = &g_aMapOverlays.Element( pSide->aOverlayIds[iOverlayId] );

-		if ( pMapOverlay )

-		{

-			if( pMapOverlay->aFaceList.Find( iFace ) == -1 )

-			{

-				pMapOverlay->aFaceList.AddToTail( iFace );

-			}

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void OverlayTransition_AddFaceToLists( int iFace, side_t *pSide )

-{

-	int nOverlayIdCount = pSide->aWaterOverlayIds.Count();

-	for( int iOverlayId = 0; iOverlayId < nOverlayIdCount; ++iOverlayId )

-	{

-		mapoverlay_t *pMapOverlay = &g_aMapWaterOverlays.Element( pSide->aWaterOverlayIds[iOverlayId] - ( MAX_MAP_OVERLAYS + 1 ) );

-		if ( pMapOverlay )

-		{

-			if( pMapOverlay->aFaceList.Find( iFace ) == -1 )

-			{

-				pMapOverlay->aFaceList.AddToTail( iFace );

-			}

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void Overlay_EmitOverlayFace( mapoverlay_t *pMapOverlay )

-{

- 	Assert( g_nOverlayCount < MAX_MAP_OVERLAYS );

-	if ( g_nOverlayCount >= MAX_MAP_OVERLAYS )

-	{

-		Error ( "Too Many Overlays!\nMAX_MAP_OVERLAYS = %d", MAX_MAP_OVERLAYS );

-		return;

-	}

-

-	doverlay_t *pOverlay = &g_Overlays[g_nOverlayCount];

-	doverlayfade_t *pOverlayFade = &g_OverlayFades[g_nOverlayCount];

-

-	g_nOverlayCount++;

-

-	// Conver the map overlay into a .bsp overlay (doverlay_t).

-	if ( pOverlay )

-	{

-		pOverlay->nId = pMapOverlay->nId;

-

-		pOverlay->flU[0] = pMapOverlay->flU[0];

-		pOverlay->flU[1] = pMapOverlay->flU[1];

-		pOverlay->flV[0] = pMapOverlay->flV[0];

-		pOverlay->flV[1] = pMapOverlay->flV[1];

-

-		VectorCopy( pMapOverlay->vecUVPoints[0], pOverlay->vecUVPoints[0] );

-		VectorCopy( pMapOverlay->vecUVPoints[1], pOverlay->vecUVPoints[1] );

-		VectorCopy( pMapOverlay->vecUVPoints[2], pOverlay->vecUVPoints[2] );

-		VectorCopy( pMapOverlay->vecUVPoints[3], pOverlay->vecUVPoints[3] );

-

-		VectorCopy( pMapOverlay->vecOrigin, pOverlay->vecOrigin );

-

-		VectorCopy( pMapOverlay->vecBasis[2], pOverlay->vecBasisNormal );

-

-		pOverlay->SetRenderOrder( pMapOverlay->m_nRenderOrder );

-

-		// Encode the BasisU into the unused z component of the vecUVPoints 0, 1, 2

-		pOverlay->vecUVPoints[0].z = pMapOverlay->vecBasis[0].x;

-		pOverlay->vecUVPoints[1].z = pMapOverlay->vecBasis[0].y;

-		pOverlay->vecUVPoints[2].z = pMapOverlay->vecBasis[0].z;

-

-		// Encode whether or not the v axis should be flipped.

-		Vector vecCross = pMapOverlay->vecBasis[2].Cross( pMapOverlay->vecBasis[0] );

-		if ( vecCross.Dot( pMapOverlay->vecBasis[1] ) < 0.0f )

-		{

-			pOverlay->vecUVPoints[3].z = 1.0f;

-		}

-

-		// Texinfo.

-		texinfo_t texInfo;

-		texInfo.flags = 0;

-		texInfo.texdata = FindOrCreateTexData( pMapOverlay->szMaterialName );

-		for( int iVec = 0; iVec < 2; ++iVec )

-		{

-			for( int iAxis = 0; iAxis < 3; ++iAxis )

-			{

-				texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][iAxis] = 0.0f;

-				texInfo.textureVecsTexelsPerWorldUnits[iVec][iAxis] = 0.0f;

-			}

-

-			texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][3] = -99999.0f;

-			texInfo.textureVecsTexelsPerWorldUnits[iVec][3] = -99999.0f;			

-		}

-		pOverlay->nTexInfo = FindOrCreateTexInfo( texInfo );

-

-		// Face List

-		int nFaceCount = pMapOverlay->aFaceList.Count();

-		Assert( nFaceCount < OVERLAY_BSP_FACE_COUNT );

-		if ( nFaceCount >= OVERLAY_BSP_FACE_COUNT )

-		{

-			Error( "Overlay touching too many faces (touching %d, max %d)\nOverlay %s at %.1f %.1f %.1f", nFaceCount, OVERLAY_BSP_FACE_COUNT, pMapOverlay->szMaterialName, pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z );

-			return;

-		}

-

-		pOverlay->SetFaceCount( nFaceCount );

-		for( int iFace = 0; iFace < nFaceCount; ++iFace )

-		{

-			pOverlay->aFaces[iFace] = pMapOverlay->aFaceList.Element( iFace );

-		}

-	}

-

-	// Convert the map overlay fade data into a .bsp overlay fade (doverlayfade_t).

-	if ( pOverlayFade )

-	{

-		pOverlayFade->flFadeDistMinSq = pMapOverlay->flFadeDistMinSq;

-		pOverlayFade->flFadeDistMaxSq = pMapOverlay->flFadeDistMaxSq;

-	}

-}

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void OverlayTransition_EmitOverlayFace( mapoverlay_t *pMapOverlay )

-{

-	Assert( g_nWaterOverlayCount < MAX_MAP_WATEROVERLAYS );

-	if ( g_nWaterOverlayCount >= MAX_MAP_WATEROVERLAYS )

-	{

-		Error ( "Too many water overlays!\nMAX_MAP_WATEROVERLAYS = %d", MAX_MAP_WATEROVERLAYS );

-		return;

-	}

-

-	dwateroverlay_t *pOverlay = &g_WaterOverlays[g_nWaterOverlayCount];

-	g_nWaterOverlayCount++;

-

-	// Conver the map overlay into a .bsp overlay (doverlay_t).

-	if ( pOverlay )

-	{

-		pOverlay->nId = pMapOverlay->nId;

-

-		pOverlay->flU[0] = pMapOverlay->flU[0];

-		pOverlay->flU[1] = pMapOverlay->flU[1];

-		pOverlay->flV[0] = pMapOverlay->flV[0];

-		pOverlay->flV[1] = pMapOverlay->flV[1];

-

-		VectorCopy( pMapOverlay->vecUVPoints[0], pOverlay->vecUVPoints[0] );

-		VectorCopy( pMapOverlay->vecUVPoints[1], pOverlay->vecUVPoints[1] );

-		VectorCopy( pMapOverlay->vecUVPoints[2], pOverlay->vecUVPoints[2] );

-		VectorCopy( pMapOverlay->vecUVPoints[3], pOverlay->vecUVPoints[3] );

-

-		VectorCopy( pMapOverlay->vecOrigin, pOverlay->vecOrigin );

-

-		VectorCopy( pMapOverlay->vecBasis[2], pOverlay->vecBasisNormal );

-

-		pOverlay->SetRenderOrder( pMapOverlay->m_nRenderOrder );

-

-		// Encode the BasisU into the unused z component of the vecUVPoints 0, 1, 2

-		pOverlay->vecUVPoints[0].z = pMapOverlay->vecBasis[0].x;

-		pOverlay->vecUVPoints[1].z = pMapOverlay->vecBasis[0].y;

-		pOverlay->vecUVPoints[2].z = pMapOverlay->vecBasis[0].z;

-

-		// Encode whether or not the v axis should be flipped.

-		Vector vecCross = pMapOverlay->vecBasis[2].Cross( pMapOverlay->vecBasis[0] );

-		if ( vecCross.Dot( pMapOverlay->vecBasis[1] ) < 0.0f )

-		{

-			pOverlay->vecUVPoints[3].z = 1.0f;

-		}

-

-		// Texinfo.

-		texinfo_t texInfo;

-		texInfo.flags = 0;

-		texInfo.texdata = FindOrCreateTexData( pMapOverlay->szMaterialName );

-		for( int iVec = 0; iVec < 2; ++iVec )

-		{

-			for( int iAxis = 0; iAxis < 3; ++iAxis )

-			{

-				texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][iAxis] = 0.0f;

-				texInfo.textureVecsTexelsPerWorldUnits[iVec][iAxis] = 0.0f;

-			}

-

-			texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][3] = -99999.0f;

-			texInfo.textureVecsTexelsPerWorldUnits[iVec][3] = -99999.0f;			

-		}

-		pOverlay->nTexInfo = FindOrCreateTexInfo( texInfo );

-

-		// Face List

-		int nFaceCount = pMapOverlay->aFaceList.Count();

-		Assert( nFaceCount < WATEROVERLAY_BSP_FACE_COUNT );

-		if ( nFaceCount >= WATEROVERLAY_BSP_FACE_COUNT )

-		{

-			Error( "Water Overlay touching too many faces (touching %d, max %d)\nOverlay %s at %.1f %.1f %.1f", nFaceCount, OVERLAY_BSP_FACE_COUNT, pMapOverlay->szMaterialName, pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z );

-			return;

-		}

-

-		pOverlay->SetFaceCount( nFaceCount );

-		for( int iFace = 0; iFace < nFaceCount; ++iFace )

-		{

-			pOverlay->aFaces[iFace] = pMapOverlay->aFaceList.Element( iFace );

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-//-----------------------------------------------------------------------------

-void Overlay_EmitOverlayFaces( void )

-{

-	int nMapOverlayCount = g_aMapOverlays.Count();

-	for( int iMapOverlay = 0; iMapOverlay < nMapOverlayCount; ++iMapOverlay )

-	{

-		Overlay_EmitOverlayFace( &g_aMapOverlays.Element( iMapOverlay ) );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-//-----------------------------------------------------------------------------

-void OverlayTransition_EmitOverlayFaces( void )

-{

-	int nMapOverlayCount = g_aMapWaterOverlays.Count();

-	for( int iMapOverlay = 0; iMapOverlay < nMapOverlayCount; ++iMapOverlay )

-	{

-		OverlayTransition_EmitOverlayFace( &g_aMapWaterOverlays.Element( iMapOverlay ) );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// These routines were mostly stolen from MapOverlay.cpp in Hammer

-//-----------------------------------------------------------------------------

-#define OVERLAY_BASIS_U					0

-#define OVERLAY_BASIS_V					1

-#define OVERLAY_BASIS_NORMAL			2	

-#define OVERLAY_HANDLES_COUNT			4

-

-

-inline void TransformPoint( const VMatrix& matrix, Vector &point )

-{

-	Vector orgVector = point;

-	matrix.V3Mul( orgVector, point );

-}

-

-

-inline bool fequal( float value, float target, float delta) { return ( (value<(target+delta))&&(value>(target-delta)) ); }

-

-

-//-----------------------------------------------------------------------------

-// Purpose: this function translate / rotate an overlay.

-// Input  : pOverlay - the overlay to be translated

-//			OriginOffset - the translation

-//			AngleOffset - the rotation

-//			Matrix - the translation / rotation matrix

-// Output : none

-//-----------------------------------------------------------------------------

-void Overlay_Translate( mapoverlay_t *pOverlay, Vector &OriginOffset, QAngle &AngleOffset, matrix3x4_t &Matrix )

-{

-	VMatrix tmpMatrix( Matrix );

-

-	Vector	temp = pOverlay->vecOrigin;

-	VectorTransform( temp, Matrix, pOverlay->vecOrigin );

-

-	// 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)

-		pOverlay->vecBasis[OVERLAY_BASIS_U].NormalizeInPlace();

-		pOverlay->vecBasis[OVERLAY_BASIS_V].NormalizeInPlace();

-

-		Vector vecU = pOverlay->vecBasis[OVERLAY_BASIS_U];

-		Vector vecV = pOverlay->vecBasis[OVERLAY_BASIS_V];

-		Vector vecNormal = pOverlay->vecBasis[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

-			pOverlay->vecBasis[OVERLAY_BASIS_U] = vecU;

-			pOverlay->vecBasis[OVERLAY_BASIS_V] = vecV;

-			pOverlay->vecBasis[OVERLAY_BASIS_NORMAL] = vecNormal;

-		}

-		else

-		{

-			// more complex transformation, move UV coordinates, but leave base axes 

-			for ( int iHandle=0; iHandle<OVERLAY_HANDLES_COUNT;iHandle++)

-			{

-				Vector vecUV = pOverlay->vecUVPoints[iHandle];

-				Vector vecPos = ( vecUV.x * pOverlay->vecBasis[OVERLAY_BASIS_U] + vecUV.y * pOverlay->vecBasis[OVERLAY_BASIS_V] );

-

-				// to transform in world space

-				TransformPoint( tmpMatrix, vecPos );

-

-				vecUV.x = pOverlay->vecBasis[OVERLAY_BASIS_U].Dot( vecPos );

-				vecUV.y = pOverlay->vecBasis[OVERLAY_BASIS_V].Dot( vecPos );

-

-				pOverlay->vecUVPoints[iHandle] = vecUV;

-			}

-		}

-	}

-

-}

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "vbsp.h"
+#include "disp_vbsp.h"
+#include "builddisp.h"
+#include "mathlib/vmatrix.h"
+
+void Overlay_BuildBasisOrigin( doverlay_t *pOverlay );
+
+// Overlay list.
+CUtlVector<mapoverlay_t> g_aMapOverlays;
+CUtlVector<mapoverlay_t> g_aMapWaterOverlays;
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int Overlay_GetFromEntity( entity_t *pMapEnt )
+{
+	int iAccessorID = -1;
+
+	// Allocate the new overlay.
+	int iOverlay = g_aMapOverlays.AddToTail();
+	mapoverlay_t *pMapOverlay = &g_aMapOverlays[iOverlay];
+
+	// Get the overlay data.
+	pMapOverlay->nId = g_aMapOverlays.Count() - 1;
+
+	if ( ValueForKey( pMapEnt, "targetname" )[ 0 ] != '\0' )
+	{
+		// Overlay has a name, remember it's ID for accessing
+		iAccessorID = pMapOverlay->nId;
+	}
+
+	pMapOverlay->flU[0] = FloatForKey( pMapEnt, "StartU" );
+	pMapOverlay->flU[1] = FloatForKey( pMapEnt, "EndU" );
+	pMapOverlay->flV[0] = FloatForKey( pMapEnt, "StartV" );
+	pMapOverlay->flV[1] = FloatForKey( pMapEnt, "EndV" );
+
+	pMapOverlay->flFadeDistMinSq = FloatForKey( pMapEnt, "fademindist" );
+	if ( pMapOverlay->flFadeDistMinSq > 0 )
+	{
+		pMapOverlay->flFadeDistMinSq *= pMapOverlay->flFadeDistMinSq;
+	}
+
+	pMapOverlay->flFadeDistMaxSq = FloatForKey( pMapEnt, "fademaxdist" );
+	if ( pMapOverlay->flFadeDistMaxSq > 0 )
+	{
+		pMapOverlay->flFadeDistMaxSq *= pMapOverlay->flFadeDistMaxSq;
+	}
+
+	GetVectorForKey( pMapEnt, "BasisOrigin", pMapOverlay->vecOrigin );
+
+	pMapOverlay->m_nRenderOrder = IntForKey( pMapEnt, "RenderOrder" );
+	if ( pMapOverlay->m_nRenderOrder < 0 || pMapOverlay->m_nRenderOrder >= OVERLAY_NUM_RENDER_ORDERS )
+		Error( "Overlay (%s) at %f %f %f has invalid render order (%d).\n", ValueForKey( pMapEnt, "material" ),
+				pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z,
+				pMapOverlay->m_nRenderOrder );
+
+	GetVectorForKey( pMapEnt, "uv0", pMapOverlay->vecUVPoints[0] );
+	GetVectorForKey( pMapEnt, "uv1", pMapOverlay->vecUVPoints[1] );
+	GetVectorForKey( pMapEnt, "uv2", pMapOverlay->vecUVPoints[2] );
+	GetVectorForKey( pMapEnt, "uv3", pMapOverlay->vecUVPoints[3] );
+
+	GetVectorForKey( pMapEnt, "BasisU", pMapOverlay->vecBasis[0] );
+	GetVectorForKey( pMapEnt, "BasisV", pMapOverlay->vecBasis[1] );
+	GetVectorForKey( pMapEnt, "BasisNormal", pMapOverlay->vecBasis[2] );
+
+	const char *pMaterialName = ValueForKey( pMapEnt, "material" );
+	Assert( strlen( pMaterialName ) < OVERLAY_MAP_STRLEN );
+	if ( strlen( pMaterialName ) >= OVERLAY_MAP_STRLEN )
+	{
+		Error( "Overlay Material Name (%s) too long! > OVERLAY_MAP_STRLEN (%d)", pMaterialName, OVERLAY_MAP_STRLEN );
+		return -1;
+	}
+	strcpy( pMapOverlay->szMaterialName, pMaterialName );	
+
+	// Convert the sidelist to side id(s).
+	const char *pSideList = ValueForKey( pMapEnt, "sides" );
+	char *pTmpList = ( char* )_alloca( strlen( pSideList ) + 1 );
+	strcpy( pTmpList, pSideList );
+	const char *pScan = strtok( pTmpList, " " );
+	if ( !pScan )
+		return iAccessorID;
+
+	pMapOverlay->aSideList.Purge();
+	pMapOverlay->aFaceList.Purge();
+
+	do
+	{
+		int nSideId;
+		if ( sscanf( pScan, "%d", &nSideId ) == 1 )
+		{
+			pMapOverlay->aSideList.AddToTail( nSideId );
+		}
+	} while ( ( pScan = strtok( NULL, " " ) ) );
+
+	return iAccessorID;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+side_t *GetSide( int nSideId )
+{
+	for( int iSide = 0; iSide < g_LoadingMap->nummapbrushsides; ++iSide )
+	{
+		if ( g_LoadingMap->brushsides[iSide].id == nSideId )
+			return &g_LoadingMap->brushsides[iSide];
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Overlay_UpdateSideLists( int StartIndex )
+{
+	int nMapOverlayCount = g_aMapOverlays.Count();
+	for( int iMapOverlay = StartIndex; iMapOverlay < nMapOverlayCount; ++iMapOverlay )
+	{
+		mapoverlay_t *pMapOverlay = &g_aMapOverlays.Element( iMapOverlay );
+		if ( pMapOverlay )
+		{
+			int nSideCount = pMapOverlay->aSideList.Count();
+			for( int iSide = 0; iSide < nSideCount; ++iSide )
+			{
+				side_t *pSide = GetSide( pMapOverlay->aSideList[iSide] );
+				if ( pSide )
+				{
+					if ( pSide->aOverlayIds.Find( pMapOverlay->nId ) == -1 )
+					{
+						pSide->aOverlayIds.AddToTail( pMapOverlay->nId );
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void OverlayTransition_UpdateSideLists( int StartIndex )
+{
+	int nOverlayCount = g_aMapWaterOverlays.Count();
+	for( int iOverlay = StartIndex; iOverlay < nOverlayCount; ++iOverlay )
+	{
+		mapoverlay_t *pOverlay = &g_aMapWaterOverlays.Element( iOverlay );
+		if ( pOverlay )
+		{
+			int nSideCount = pOverlay->aSideList.Count();
+			for( int iSide = 0; iSide < nSideCount; ++iSide )
+			{
+				side_t *pSide = GetSide( pOverlay->aSideList[iSide] );
+				if ( pSide )
+				{
+					if ( pSide->aWaterOverlayIds.Find( pOverlay->nId ) == -1 )
+					{
+						pSide->aWaterOverlayIds.AddToTail( pOverlay->nId );
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Overlay_AddFaceToLists( int iFace, side_t *pSide )
+{
+	int nOverlayIdCount = pSide->aOverlayIds.Count();
+	for( int iOverlayId = 0; iOverlayId < nOverlayIdCount; ++iOverlayId )
+	{
+		mapoverlay_t *pMapOverlay = &g_aMapOverlays.Element( pSide->aOverlayIds[iOverlayId] );
+		if ( pMapOverlay )
+		{
+			if( pMapOverlay->aFaceList.Find( iFace ) == -1 )
+			{
+				pMapOverlay->aFaceList.AddToTail( iFace );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void OverlayTransition_AddFaceToLists( int iFace, side_t *pSide )
+{
+	int nOverlayIdCount = pSide->aWaterOverlayIds.Count();
+	for( int iOverlayId = 0; iOverlayId < nOverlayIdCount; ++iOverlayId )
+	{
+		mapoverlay_t *pMapOverlay = &g_aMapWaterOverlays.Element( pSide->aWaterOverlayIds[iOverlayId] - ( MAX_MAP_OVERLAYS + 1 ) );
+		if ( pMapOverlay )
+		{
+			if( pMapOverlay->aFaceList.Find( iFace ) == -1 )
+			{
+				pMapOverlay->aFaceList.AddToTail( iFace );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void Overlay_EmitOverlayFace( mapoverlay_t *pMapOverlay )
+{
+ 	Assert( g_nOverlayCount < MAX_MAP_OVERLAYS );
+	if ( g_nOverlayCount >= MAX_MAP_OVERLAYS )
+	{
+		Error ( "Too Many Overlays!\nMAX_MAP_OVERLAYS = %d", MAX_MAP_OVERLAYS );
+		return;
+	}
+
+	doverlay_t *pOverlay = &g_Overlays[g_nOverlayCount];
+	doverlayfade_t *pOverlayFade = &g_OverlayFades[g_nOverlayCount];
+
+	g_nOverlayCount++;
+
+	// Conver the map overlay into a .bsp overlay (doverlay_t).
+	if ( pOverlay )
+	{
+		pOverlay->nId = pMapOverlay->nId;
+
+		pOverlay->flU[0] = pMapOverlay->flU[0];
+		pOverlay->flU[1] = pMapOverlay->flU[1];
+		pOverlay->flV[0] = pMapOverlay->flV[0];
+		pOverlay->flV[1] = pMapOverlay->flV[1];
+
+		VectorCopy( pMapOverlay->vecUVPoints[0], pOverlay->vecUVPoints[0] );
+		VectorCopy( pMapOverlay->vecUVPoints[1], pOverlay->vecUVPoints[1] );
+		VectorCopy( pMapOverlay->vecUVPoints[2], pOverlay->vecUVPoints[2] );
+		VectorCopy( pMapOverlay->vecUVPoints[3], pOverlay->vecUVPoints[3] );
+
+		VectorCopy( pMapOverlay->vecOrigin, pOverlay->vecOrigin );
+
+		VectorCopy( pMapOverlay->vecBasis[2], pOverlay->vecBasisNormal );
+
+		pOverlay->SetRenderOrder( pMapOverlay->m_nRenderOrder );
+
+		// Encode the BasisU into the unused z component of the vecUVPoints 0, 1, 2
+		pOverlay->vecUVPoints[0].z = pMapOverlay->vecBasis[0].x;
+		pOverlay->vecUVPoints[1].z = pMapOverlay->vecBasis[0].y;
+		pOverlay->vecUVPoints[2].z = pMapOverlay->vecBasis[0].z;
+
+		// Encode whether or not the v axis should be flipped.
+		Vector vecCross = pMapOverlay->vecBasis[2].Cross( pMapOverlay->vecBasis[0] );
+		if ( vecCross.Dot( pMapOverlay->vecBasis[1] ) < 0.0f )
+		{
+			pOverlay->vecUVPoints[3].z = 1.0f;
+		}
+
+		// Texinfo.
+		texinfo_t texInfo;
+		texInfo.flags = 0;
+		texInfo.texdata = FindOrCreateTexData( pMapOverlay->szMaterialName );
+		for( int iVec = 0; iVec < 2; ++iVec )
+		{
+			for( int iAxis = 0; iAxis < 3; ++iAxis )
+			{
+				texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][iAxis] = 0.0f;
+				texInfo.textureVecsTexelsPerWorldUnits[iVec][iAxis] = 0.0f;
+			}
+
+			texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][3] = -99999.0f;
+			texInfo.textureVecsTexelsPerWorldUnits[iVec][3] = -99999.0f;			
+		}
+		pOverlay->nTexInfo = FindOrCreateTexInfo( texInfo );
+
+		// Face List
+		int nFaceCount = pMapOverlay->aFaceList.Count();
+		Assert( nFaceCount < OVERLAY_BSP_FACE_COUNT );
+		if ( nFaceCount >= OVERLAY_BSP_FACE_COUNT )
+		{
+			Error( "Overlay touching too many faces (touching %d, max %d)\nOverlay %s at %.1f %.1f %.1f", nFaceCount, OVERLAY_BSP_FACE_COUNT, pMapOverlay->szMaterialName, pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z );
+			return;
+		}
+
+		pOverlay->SetFaceCount( nFaceCount );
+		for( int iFace = 0; iFace < nFaceCount; ++iFace )
+		{
+			pOverlay->aFaces[iFace] = pMapOverlay->aFaceList.Element( iFace );
+		}
+	}
+
+	// Convert the map overlay fade data into a .bsp overlay fade (doverlayfade_t).
+	if ( pOverlayFade )
+	{
+		pOverlayFade->flFadeDistMinSq = pMapOverlay->flFadeDistMinSq;
+		pOverlayFade->flFadeDistMaxSq = pMapOverlay->flFadeDistMaxSq;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void OverlayTransition_EmitOverlayFace( mapoverlay_t *pMapOverlay )
+{
+	Assert( g_nWaterOverlayCount < MAX_MAP_WATEROVERLAYS );
+	if ( g_nWaterOverlayCount >= MAX_MAP_WATEROVERLAYS )
+	{
+		Error ( "Too many water overlays!\nMAX_MAP_WATEROVERLAYS = %d", MAX_MAP_WATEROVERLAYS );
+		return;
+	}
+
+	dwateroverlay_t *pOverlay = &g_WaterOverlays[g_nWaterOverlayCount];
+	g_nWaterOverlayCount++;
+
+	// Conver the map overlay into a .bsp overlay (doverlay_t).
+	if ( pOverlay )
+	{
+		pOverlay->nId = pMapOverlay->nId;
+
+		pOverlay->flU[0] = pMapOverlay->flU[0];
+		pOverlay->flU[1] = pMapOverlay->flU[1];
+		pOverlay->flV[0] = pMapOverlay->flV[0];
+		pOverlay->flV[1] = pMapOverlay->flV[1];
+
+		VectorCopy( pMapOverlay->vecUVPoints[0], pOverlay->vecUVPoints[0] );
+		VectorCopy( pMapOverlay->vecUVPoints[1], pOverlay->vecUVPoints[1] );
+		VectorCopy( pMapOverlay->vecUVPoints[2], pOverlay->vecUVPoints[2] );
+		VectorCopy( pMapOverlay->vecUVPoints[3], pOverlay->vecUVPoints[3] );
+
+		VectorCopy( pMapOverlay->vecOrigin, pOverlay->vecOrigin );
+
+		VectorCopy( pMapOverlay->vecBasis[2], pOverlay->vecBasisNormal );
+
+		pOverlay->SetRenderOrder( pMapOverlay->m_nRenderOrder );
+
+		// Encode the BasisU into the unused z component of the vecUVPoints 0, 1, 2
+		pOverlay->vecUVPoints[0].z = pMapOverlay->vecBasis[0].x;
+		pOverlay->vecUVPoints[1].z = pMapOverlay->vecBasis[0].y;
+		pOverlay->vecUVPoints[2].z = pMapOverlay->vecBasis[0].z;
+
+		// Encode whether or not the v axis should be flipped.
+		Vector vecCross = pMapOverlay->vecBasis[2].Cross( pMapOverlay->vecBasis[0] );
+		if ( vecCross.Dot( pMapOverlay->vecBasis[1] ) < 0.0f )
+		{
+			pOverlay->vecUVPoints[3].z = 1.0f;
+		}
+
+		// Texinfo.
+		texinfo_t texInfo;
+		texInfo.flags = 0;
+		texInfo.texdata = FindOrCreateTexData( pMapOverlay->szMaterialName );
+		for( int iVec = 0; iVec < 2; ++iVec )
+		{
+			for( int iAxis = 0; iAxis < 3; ++iAxis )
+			{
+				texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][iAxis] = 0.0f;
+				texInfo.textureVecsTexelsPerWorldUnits[iVec][iAxis] = 0.0f;
+			}
+
+			texInfo.lightmapVecsLuxelsPerWorldUnits[iVec][3] = -99999.0f;
+			texInfo.textureVecsTexelsPerWorldUnits[iVec][3] = -99999.0f;			
+		}
+		pOverlay->nTexInfo = FindOrCreateTexInfo( texInfo );
+
+		// Face List
+		int nFaceCount = pMapOverlay->aFaceList.Count();
+		Assert( nFaceCount < WATEROVERLAY_BSP_FACE_COUNT );
+		if ( nFaceCount >= WATEROVERLAY_BSP_FACE_COUNT )
+		{
+			Error( "Water Overlay touching too many faces (touching %d, max %d)\nOverlay %s at %.1f %.1f %.1f", nFaceCount, OVERLAY_BSP_FACE_COUNT, pMapOverlay->szMaterialName, pMapOverlay->vecOrigin.x, pMapOverlay->vecOrigin.y, pMapOverlay->vecOrigin.z );
+			return;
+		}
+
+		pOverlay->SetFaceCount( nFaceCount );
+		for( int iFace = 0; iFace < nFaceCount; ++iFace )
+		{
+			pOverlay->aFaces[iFace] = pMapOverlay->aFaceList.Element( iFace );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Overlay_EmitOverlayFaces( void )
+{
+	int nMapOverlayCount = g_aMapOverlays.Count();
+	for( int iMapOverlay = 0; iMapOverlay < nMapOverlayCount; ++iMapOverlay )
+	{
+		Overlay_EmitOverlayFace( &g_aMapOverlays.Element( iMapOverlay ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void OverlayTransition_EmitOverlayFaces( void )
+{
+	int nMapOverlayCount = g_aMapWaterOverlays.Count();
+	for( int iMapOverlay = 0; iMapOverlay < nMapOverlayCount; ++iMapOverlay )
+	{
+		OverlayTransition_EmitOverlayFace( &g_aMapWaterOverlays.Element( iMapOverlay ) );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// These routines were mostly stolen from MapOverlay.cpp in Hammer
+//-----------------------------------------------------------------------------
+#define OVERLAY_BASIS_U					0
+#define OVERLAY_BASIS_V					1
+#define OVERLAY_BASIS_NORMAL			2	
+#define OVERLAY_HANDLES_COUNT			4
+
+
+inline void TransformPoint( const VMatrix& matrix, Vector &point )
+{
+	Vector orgVector = point;
+	matrix.V3Mul( orgVector, point );
+}
+
+
+inline bool fequal( float value, float target, float delta) { return ( (value<(target+delta))&&(value>(target-delta)) ); }
+
+
+//-----------------------------------------------------------------------------
+// Purpose: this function translate / rotate an overlay.
+// Input  : pOverlay - the overlay to be translated
+//			OriginOffset - the translation
+//			AngleOffset - the rotation
+//			Matrix - the translation / rotation matrix
+// Output : none
+//-----------------------------------------------------------------------------
+void Overlay_Translate( mapoverlay_t *pOverlay, Vector &OriginOffset, QAngle &AngleOffset, matrix3x4_t &Matrix )
+{
+	VMatrix tmpMatrix( Matrix );
+
+	Vector	temp = pOverlay->vecOrigin;
+	VectorTransform( temp, Matrix, pOverlay->vecOrigin );
+
+	// 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)
+		pOverlay->vecBasis[OVERLAY_BASIS_U].NormalizeInPlace();
+		pOverlay->vecBasis[OVERLAY_BASIS_V].NormalizeInPlace();
+
+		Vector vecU = pOverlay->vecBasis[OVERLAY_BASIS_U];
+		Vector vecV = pOverlay->vecBasis[OVERLAY_BASIS_V];
+		Vector vecNormal = pOverlay->vecBasis[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
+			pOverlay->vecBasis[OVERLAY_BASIS_U] = vecU;
+			pOverlay->vecBasis[OVERLAY_BASIS_V] = vecV;
+			pOverlay->vecBasis[OVERLAY_BASIS_NORMAL] = vecNormal;
+		}
+		else
+		{
+			// more complex transformation, move UV coordinates, but leave base axes 
+			for ( int iHandle=0; iHandle<OVERLAY_HANDLES_COUNT;iHandle++)
+			{
+				Vector vecUV = pOverlay->vecUVPoints[iHandle];
+				Vector vecPos = ( vecUV.x * pOverlay->vecBasis[OVERLAY_BASIS_U] + vecUV.y * pOverlay->vecBasis[OVERLAY_BASIS_V] );
+
+				// to transform in world space
+				TransformPoint( tmpMatrix, vecPos );
+
+				vecUV.x = pOverlay->vecBasis[OVERLAY_BASIS_U].Dot( vecPos );
+				vecUV.y = pOverlay->vecBasis[OVERLAY_BASIS_V].Dot( vecPos );
+
+				pOverlay->vecUVPoints[iHandle] = vecUV;
+			}
+		}
+	}
+
+}