tf2/tf2_src/vphysics/trace.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"
#include "cmodel.h"
#include "physics_trace.h"
#include "ivp_surman_polygon.hxx"
#include "ivp_compact_ledge.hxx"
#include "ivp_compact_ledge_solver.hxx"
#include "ivp_compact_surface.hxx"
#include "tier0/vprof.h"
#include "mathlib/ssemath.h"
#include "tier0/tslist.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

// this skips the sphere tree stuff for tracing
#define DEBUG_TEST_ALL_LEDGES 0
// this skips the optimization that shrinks the ray as each intersection is encountered
#define DEBUG_KEEP_FULL_RAY 0
// this skips the optimization that looks up the first vert in a cubemap
#define USE_COLLIDE_MAP 1

// objects with small numbers of verts build a cache of pre-transformed verts
#define USE_VERT_CACHE 1
#define USE_RLE_SPANS 1

// UNDONE: This is a boost on PC, but doesn't work yet on x360 - investigate
#define SIMD_MATRIX	0

// turn this on to get asserts in the low-level collision solver
#define CHECK_TOI_CALCS 0

#define BRUTE_FORCE_VERT_COUNT 128

// NOTE: This is in inches (HL units)
#define TEST_EPSILON	(g_PhysicsUnits.collisionSweepIncrementalEpsilon)

struct simplexvert_t
{
	Vector	position;
	unsigned short testIndex : 15;
	unsigned short sweepIndex : 1;
	unsigned short obstacleIndex;
};

struct simplex_t
{
	simplexvert_t	verts[4];
	int				vertCount;

	inline bool PointSimplex( const simplexvert_t &newPoint, Vector *pOut );
	inline bool EdgeSimplex( const simplexvert_t &newPoint, int outIndex, const Vector &edge, Vector *pOut );
	inline bool TriangleSimplex( const simplexvert_t &newPoint, int outIndex, const Vector &faceNormal, Vector *pOut );

	bool SolveGJKSet( const simplexvert_t &newPoint, Vector *pOut );
	bool SolveVoronoiRegion2( const simplexvert_t &newPoint, Vector *pOut );
	bool SolveVoronoiRegion3( const simplexvert_t &newPoint, Vector *pOut );
	bool SolveVoronoiRegion4( const simplexvert_t &newPoint, Vector *pOut );

	Vector ClipRayToTetrahedronBase( const Vector &dir );
	Vector ClipRayToTetrahedron( const Vector &dir );
	float ClipRayToTriangle( const Vector &dir, float epsilon );
};

class CTraceCone : public ITraceObject
{
public:
	CTraceCone( const truncatedcone_t &cone, const Vector &translation )
	{
		m_cone = cone;
		m_cone.origin += translation;
		float cosTheta;
		SinCos( DEG2RAD(m_cone.theta), &m_sinTheta, &cosTheta );
		m_radius = m_cone.h * m_sinTheta / cosTheta;
		m_centerBase = m_cone.origin + m_cone.h * m_cone.normal;
	}

	virtual int SupportMap( const Vector &dir, Vector *pOut ) const
	{
		Vector unitDir = dir;
		VectorNormalize(unitDir);

		float dot = DotProduct( unitDir, m_cone.normal );

		// anti-cone is -normal, angle = 90 - theta
		// If the normal is in the anti-cone, then return the apex

		// not in anti-cone, support map is on the surface of the disc
		if ( dot > -m_sinTheta )
		{
			unitDir -= m_cone.normal * dot;
			float len = VectorNormalize( unitDir );
			if ( len > 1e-4f )
			{
				*pOut = m_centerBase + (unitDir * m_radius);
				return 0;
			}
			*pOut = m_centerBase;
			return 0;


		}
		// outside the cone's angle, support map is on the surface of the cone
		*pOut = m_cone.origin;
		return 0;
	}

	// BUGBUG: Doesn't work!
	virtual Vector GetVertByIndex( int index ) const { return  m_cone.origin; }
	virtual float Radius( void ) const { return m_cone.h + m_radius; }

	truncatedcone_t	m_cone;
	float			m_radius;
	float			m_sinTheta;
	Vector			m_centerBase;
};

 
// really this is indexing a vertex, but the iteration code needs a triangle + edge index.
// edge is always 0-2 so return it in the bottom 2 bits
static unsigned short GetPackedIndex( const IVP_Compact_Ledge *pLedge, const IVP_U_Float_Point &dir )
{
	const IVP_Compact_Poly_Point *RESTRICT pPoints = pLedge->get_point_array();
	const IVP_Compact_Triangle *RESTRICT pTri = pLedge->get_first_triangle();
	const IVP_Compact_Edge *RESTRICT pEdge = pTri->get_edge( 0 );
	int best = pEdge->get_start_point_index();
	float bestDot = pPoints[best].dot_product( &dir );
	int triCount = pLedge->get_n_triangles();
	const IVP_Compact_Triangle *RESTRICT pBestTri = pTri;
	// this loop will early out, but keep it from being infinite
	int i;
	// hillclimbing search to find the best support vert
	for ( i = 0; i < triCount; i++ )
	{
		// get the index to the end vert of this edge (start vert on next edge)
		pEdge = pEdge->get_prev();
		int stopVert = pEdge->get_start_point_index();

		// loop through the verts that can be reached along edges from this vert
		// stop if you get back to the one you're starting on.
		int vert = stopVert;
		do
		{
			float dot = pPoints[vert].dot_product( &dir );
			if ( dot > bestDot )
			{
				bestDot = dot;
				best = vert;
				pBestTri = pEdge->get_triangle();
				break;
			}
			// tri opposite next edge, same starting vert as next edge
			pEdge = pEdge->get_opposite()->get_prev();
			vert = pEdge->get_start_point_index();
		} while ( vert != stopVert );

		// if you exhausted the possibilities for this vert, it must be the best vert
		if ( vert != best )
			break;
	}

	int triIndex = pBestTri - pLedge->get_first_triangle();
	int edgeIndex = 0;
	// just do a search for the edge containing this vert instead of storing it along the way
	for ( i = 0; i < 3; i++ )
	{
		if ( pBestTri->get_edge(i)->get_start_point_index() == best )
		{
			edgeIndex = i;
			break;
		}
	}

	return (unsigned short) ( (triIndex<<2) + edgeIndex );
}


void InitLeafmap( IVP_Compact_Ledge *pLedge, leafmap_t *pLeafmapOut )
{
	pLeafmapOut->pLeaf = pLedge;
	pLeafmapOut->vertCount = 0;
	pLeafmapOut->flags = 0;
	pLeafmapOut->spanCount = 0;
	if ( pLedge && pLedge->is_terminal() )
	{
		// for small numbers of verts it's much faster to simply do dot products with all verts
		// since the best case for hillclimbing is to touch the start vert plus all neighbors (avg_valence+1 dots)
		// in t
		int triCount = pLedge->get_n_triangles();
		// this is a guess that anything with more than brute_force * 4 tris will have at least brute_force verts
		if ( triCount <= BRUTE_FORCE_VERT_COUNT*4 )
		{
			Assert(triCount>0);
			int minV = MAX_CONVEX_VERTS;
			int maxV = 0;
			for ( int i = 0; i < triCount; i++ )
			{
				const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
				for ( int j = 0; j < 3; j++ )
				{
					const IVP_Compact_Edge *pEdge = pTri->get_edge( j );
					int v = pEdge->get_start_point_index();
					if ( v < minV )
					{
						minV = v;
					}
					if ( v > maxV )
					{
						maxV = v;
					}
				}
			}
			int vertCount = (maxV-minV) + 1;
			// max possible verts is < 48, so this is just here for some real failure
			// or vert sharing with a large collection of convexes.  In that case the 
			// number could be high, but this approach to implementing support is invalid
			// because the vert range is polluted
			if ( vertCount < BRUTE_FORCE_VERT_COUNT )
			{
				char hasVert[BRUTE_FORCE_VERT_COUNT];
				memset(hasVert, 0, sizeof(hasVert[0])*vertCount);
				for ( int i = 0; i < triCount; i++ )
				{
					const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle() + i;
					for ( int j = 0; j < 3; j++ )
					{
						// mark each vert in the list
						const IVP_Compact_Edge *pEdge = pTri->get_edge( j );
						int v = pEdge->get_start_point_index();
						hasVert[v-minV] = true;
					}
				}
				// now find the vertex spans and encode them
				byte spans[BRUTE_FORCE_VERT_COUNT];
				int spanIndex = 0;
				char has = hasVert[0];
				Assert(has);
				byte count = 1;
				for ( int i = 1; i < vertCount && spanIndex < BRUTE_FORCE_VERT_COUNT; i++ )
				{
					// each change of state is a new span
					if ( has != hasVert[i] )
					{
						spans[spanIndex] = count;
						has = hasVert[i];
						count = 0;
						spanIndex++;
					}
					count++;
					Assert(count < 255);
				}

				// rle spans only supported with vertex caching
#if USE_VERT_CACHE && USE_RLE_SPANS
				if ( spanIndex < BRUTE_FORCE_VERT_COUNT )
#else
				if ( spanIndex < 1 )
#endif
				{
					spans[spanIndex] = count;
					spanIndex++;
					pLeafmapOut->SetRLESpans( minV, spanIndex, spans );
				}
			}
		}
	}

	if ( !pLeafmapOut->HasSpans() )
	{
		// otherwise make a 8-way directional map to pick the best start vert for hillclimbing
		pLeafmapOut->SetHasCubemap();
		for ( int i = 0; i < 8; i++ )
		{
			IVP_U_Float_Point tmp;
			tmp.k[0] = ( i & 1 ) ? -1 : 1;
			tmp.k[1] = ( i & 2 ) ? -1 : 1;
			tmp.k[2] = ( i & 4 ) ? -1 : 1;
			pLeafmapOut->startVert[i] = GetPackedIndex( pLedge, tmp );
		}
	}
}


void GetStartVert( const leafmap_t *pLeafmap, const IVP_U_Float_Point &localDirection, int &triIndex, int &edgeIndex )
{
	if ( !pLeafmap || !pLeafmap->HasCubemap() )
		return;

	// map dir to index
	int cacheIndex = (localDirection.k[0] < 0 ? 1 : 0) + (localDirection.k[1] < 0 ? 2 : 0) + (localDirection.k[2] < 0 ? 4 : 0 );
	triIndex = pLeafmap->startVert[cacheIndex] >> 2;
	edgeIndex = pLeafmap->startVert[cacheIndex] & 0x3;
}

CTSPool<CVisitHash> g_VisitHashPool;

CVisitHash *AllocVisitHash()
{
	return g_VisitHashPool.GetObject();
}

void FreeVisitHash(CVisitHash *pFree)
{
	if ( pFree )
	{
		g_VisitHashPool.PutObject(pFree);
	}
}

//-----------------------------------------------------------------------------
// Purpose: Implementation for Trace against an IVP object
//-----------------------------------------------------------------------------
class CTraceIVP : public ITraceObject
{
public:
	CTraceIVP( const CPhysCollide *pCollide, const Vector &origin, const QAngle &angles );
	~CTraceIVP()
	{
		if ( m_pVisitHash )
			FreeVisitHash(m_pVisitHash);
	}
	virtual int SupportMap( const Vector &dir, Vector *pOut ) const;
	virtual Vector GetVertByIndex( int index ) const;

	// UNDONE: Do general ITraceObject center/offset computation and move the ray to account
	// for this delta like we do in TraceSweepIVP()
	// Then we can shrink the radius of objects with mass centers NOT at the origin
	virtual float Radius( void ) const 
	{ 
		return m_radius;
	}

	inline float TransformLengthToLocal( float length )
	{
		return ConvertDistanceToIVP( length );
	}
	// UNDONE: Optimize this by storing 3 matrices? (one for each transform that includes rot/scale for HL/IVP)?
	// UNDONE: Not necessary if we remove the coordinate conversion
	inline void TransformDirectionToLocal( const Vector &dir, IVP_U_Float_Point &local ) const
	{
		IVP_U_Float_Point tmp;
		ConvertDirectionToIVP( dir, tmp );
		m_matrix.vimult3( &tmp, &local );
	}

	inline void RotateRelativePositionToLocal( const Vector &delta, IVP_U_Float_Point &local ) const
	{
		IVP_U_Float_Point tmp;
		ConvertPositionToIVP( delta, tmp );
		m_matrix.vimult3( &tmp, &local );
	}

	inline void TransformPositionToLocal( const Vector &pos, IVP_U_Float_Point &local ) const
	{
		IVP_U_Float_Point tmp;
		ConvertPositionToIVP( pos, tmp );
		m_matrix.vimult4( &tmp, &local );
	}

	inline void TransformPositionFromLocal( const IVP_U_Float_Point &local, Vector &out ) const
	{
		VectorTransform( *(Vector *)&local, *((const matrix3x4_t *)&m_ivpLocalToHLWorld), out );
	}

#if USE_VERT_CACHE
	inline Vector CachedVertByIndex(int index) const
	{
		int subIndex = index & 3;
		return m_vertCache[index>>2].Vec(subIndex);
	}
#endif

	bool IsValid( void ) { return m_pLedge != NULL; }

	void AllocateVisitHash()
	{
		if ( !m_pVisitHash )
			m_pVisitHash = AllocVisitHash();
	}

	void SetLedge( const IVP_Compact_Ledge *pLedge )
	{
		m_pLedge = pLedge;
		m_pLeafmap = NULL;
		if ( !pLedge )
			return;

#if USE_VERT_CACHE
		m_cacheCount = 0;
#endif
		if ( m_pCollideMap )
		{
			for ( int i = 0; i < m_pCollideMap->leafCount; i++ )
			{
				if ( m_pCollideMap->leafmap[i].pLeaf == pLedge )
				{
					m_pLeafmap = &m_pCollideMap->leafmap[i];
					if ( !BuildLeafmapCache( &m_pCollideMap->leafmap[i] ) )
					{
						AllocateVisitHash();
					}
					return;
				}
			}
		}
		AllocateVisitHash();
	}

	bool SetSingleConvex( void )
	{
		const IVP_Compact_Ledgetree_Node *node = m_pSurface->get_compact_ledge_tree_root();
		if ( node->is_terminal() == IVP_TRUE )
		{
			SetLedge( node->get_compact_ledge() );
			return true;
		}
		SetLedge( NULL );
		return false;
	}
	bool BuildLeafmapCache(const leafmap_t * RESTRICT pLeafmap);
	bool BuildLeafmapCacheRLE( const leafmap_t * RESTRICT pLeafmap );
	inline int SupportMapCached( const Vector &dir, Vector *pOut ) const;
	const collidemap_t			*m_pCollideMap;
	const IVP_Compact_Surface	*m_pSurface;

private:
	const leafmap_t				*m_pLeafmap;
	const IVP_Compact_Ledge		*m_pLedge;
	CVisitHash					*m_pVisitHash;
#if SIMD_MATRIX
	FourVectors					m_ivpLocalToHLWorld;
#else
	matrix3x4_t					m_ivpLocalToHLWorld;
#endif
	IVP_U_Matrix				m_matrix;
	// transform that includes scale from IVP to HL coords, do not VectorITransform or VectorRotate with this
	float						m_radius;
	int							m_nPointTest;
	int							m_nStartPoint;
	bool						m_bHasTranslation;
#if USE_VERT_CACHE
	int							m_cacheCount;	// number of FourVectors used
	FourVectors					m_vertCache[BRUTE_FORCE_VERT_COUNT/4];
#endif
};

// GCC 4.2.1 can't handle loading a static const into a m128 register :(
#ifdef WIN32
static const 
#endif
fltx4 g_IVPToHLDir = { 1.0f, -1.0f, 1.0f, 1.0f };

//static const fltx4 g_IVPToHLPosition = { IVP2HL(1.0f), -IVP2HL(1.0f), IVP2HL(1.0f), IVP2HL(1.0f) };

#if defined(_X360)

FORCEINLINE fltx4 ConvertDirectionToIVP( const fltx4 & a )
{
	fltx4 t = __vpermwi( a, VPERMWI_CONST( 0, 2, 1, 3 ) );
	// negate Y
	return MulSIMD( t, g_IVPToHLDir );
}
#else
FORCEINLINE fltx4 ConvertDirectionToIVP( const fltx4 & a )
{
	// swap Z & Y
	fltx4 t = _mm_shuffle_ps( a, a, MM_SHUFFLE_REV( 0, 2, 1, 3 ) );
	// negate Y
	return MulSIMD( t, g_IVPToHLDir );
}
#endif

CTraceIVP::CTraceIVP( const CPhysCollide *pCollide, const Vector &origin, const QAngle &angles )
{
#if USE_COLLIDE_MAP
	m_pCollideMap = pCollide->GetCollideMap();
#else
	m_pCollideMap = NULL;
#endif
	m_pSurface = pCollide->GetCompactSurface();
	m_pLedge = NULL;
	m_pVisitHash = NULL;

	m_bHasTranslation = (origin==vec3_origin) ? false : true;
	// UNDONE: Move this offset calculation into the tracing routines
	// I didn't do this now because it seems to require changes to most of the
	// transform routines - and this would cause bugs.
	float centerOffset = VectorLength( m_pSurface->mass_center.k );
#if SIMD_MATRIX
	VectorAligned forward, right, up;
	IVP_U_Float_Point ivpForward, ivpLeft, ivpUp;

	AngleVectors( angles, &forward, &right, &up );

	Vector left = -right;
	Vector down = -up;

	ConvertDirectionToIVP( forward, ivpForward );
	ConvertDirectionToIVP( left, ivpLeft );
	ConvertDirectionToIVP( down, ivpUp );

	m_matrix.set_col( IVP_INDEX_X, &ivpForward );
	m_matrix.set_col( IVP_INDEX_Z, &ivpLeft );
	m_matrix.set_col( IVP_INDEX_Y, &ivpUp );
	ConvertPositionToIVP( origin, m_matrix.vv );

	forward.w = HL2IVP(origin.x);
	// This vector is supposed to be left, so we'll negate it later, but we don't want to 
	// negate the position, so add another minus to cancel out
	right.w = -HL2IVP(origin.y);
	up.w = HL2IVP(origin.z);
	fltx4 rx = ConvertDirectionToIVP(LoadAlignedSIMD(forward.Base()));
	fltx4 ry = ConvertDirectionToIVP(SubSIMD( Four_Zeros, LoadAlignedSIMD(right.Base())) );
	fltx4 rz = ConvertDirectionToIVP(LoadAlignedSIMD(up.Base()) );

	fltx4 scaleHL = ReplicateX4(IVP2HL(1.0f));
	m_ivpLocalToHLWorld.x = MulSIMD( scaleHL, rx );
	m_ivpLocalToHLWorld.y = MulSIMD( scaleHL, ry );
	m_ivpLocalToHLWorld.z = MulSIMD( scaleHL, rz );
#else
	ConvertRotationToIVP( angles, m_matrix );
	ConvertPositionToIVP( origin, m_matrix.vv );
	float scale = IVP2HL(1.0f);
	float negScale = IVP2HL(-1.0f);
	// copy the existing IVP local->world matrix (swap Y & Z)
	m_ivpLocalToHLWorld.m_flMatVal[0][0] = m_matrix.get_elem(IVP_INDEX_X,0) * scale; 
	m_ivpLocalToHLWorld.m_flMatVal[0][1] = m_matrix.get_elem(IVP_INDEX_X,1) * scale; 
	m_ivpLocalToHLWorld.m_flMatVal[0][2] = m_matrix.get_elem(IVP_INDEX_X,2) * scale; 

	m_ivpLocalToHLWorld.m_flMatVal[1][0] = m_matrix.get_elem(IVP_INDEX_Z,0) * scale; 
	m_ivpLocalToHLWorld.m_flMatVal[1][1] = m_matrix.get_elem(IVP_INDEX_Z,1) * scale; 
	m_ivpLocalToHLWorld.m_flMatVal[1][2] = m_matrix.get_elem(IVP_INDEX_Z,2) * scale; 

	m_ivpLocalToHLWorld.m_flMatVal[2][0] = m_matrix.get_elem(IVP_INDEX_Y,0) * negScale; 
	m_ivpLocalToHLWorld.m_flMatVal[2][1] = m_matrix.get_elem(IVP_INDEX_Y,1) * negScale; 
	m_ivpLocalToHLWorld.m_flMatVal[2][2] = m_matrix.get_elem(IVP_INDEX_Y,2) * negScale; 

	m_ivpLocalToHLWorld.m_flMatVal[0][3] = m_matrix.vv.k[0] * scale;
	m_ivpLocalToHLWorld.m_flMatVal[1][3] = m_matrix.vv.k[2] * scale;
	m_ivpLocalToHLWorld.m_flMatVal[2][3] = m_matrix.vv.k[1] * negScale;

#endif

	m_radius = ConvertDistanceToHL( m_pSurface->upper_limit_radius + centerOffset );
}

bool CTraceIVP::BuildLeafmapCacheRLE( const leafmap_t * RESTRICT pLeafmap )
{
	// iterate the rle spans of verts and output them to a buffer in post-transform space
	int startPoint = pLeafmap->startVert[0];
	int pointCount = pLeafmap->vertCount;
	m_cacheCount = (pointCount + 3)>>2;
	const byte *RESTRICT pSpans = pLeafmap->GetSpans();
	int countThisSpan = pSpans[0];
	int spanIndex = 1;
	int baseVert = 0;
	const VectorAligned * RESTRICT pVerts = (const VectorAligned *)&m_pLedge->get_point_array()[startPoint];
	for ( int i = 0; i < m_cacheCount-1; i++ )
	{
		if ( countThisSpan < 4 )
		{
			// unrolled for perf
			// we need a batch of four verts, but they aren't in a single span
			int v0, v1, v2, v3;
			if ( !countThisSpan )
			{
				baseVert += pSpans[spanIndex];
				countThisSpan = pSpans[spanIndex+1];
				spanIndex += 2;
			}
			v0 = baseVert++;
			countThisSpan--;
			if ( !countThisSpan )
			{
				baseVert += pSpans[spanIndex];
				countThisSpan = pSpans[spanIndex+1];
				spanIndex += 2;
			}
			v1 = baseVert++;
			countThisSpan--;
			if ( !countThisSpan )
			{
				baseVert += pSpans[spanIndex];
				countThisSpan = pSpans[spanIndex+1];
				spanIndex += 2;
			}
			v2 = baseVert++;
			countThisSpan--;
			if ( !countThisSpan )
			{
				baseVert += pSpans[spanIndex];
				countThisSpan = pSpans[spanIndex+1];
				spanIndex += 2;
			}
			v3 = baseVert++;
			countThisSpan--;
			m_vertCache[i].LoadAndSwizzleAligned( pVerts[v0].Base(), pVerts[v1].Base(), pVerts[v2].Base(), pVerts[v3].Base() );
		}
		else
		{
			// we have four verts in this span, just grab the next four
			m_vertCache[i].LoadAndSwizzleAligned( pVerts[baseVert+0].Base(), pVerts[baseVert+1].Base(), pVerts[baseVert+2].Base(), pVerts[baseVert+3].Base() );
			baseVert += 4;
			countThisSpan -= 4;
		}
	}
	// the last iteration needs multiple spans and clamping to the last vert
	int v[4];
	for ( int i = 0; i < 4; i++ )
	{
		if ( spanIndex < pLeafmap->spanCount && !countThisSpan )
		{
			baseVert += pSpans[spanIndex];
			countThisSpan = pSpans[spanIndex+1];
			spanIndex += 2;
		}
		if ( spanIndex < pLeafmap->spanCount )
		{
			v[i] = baseVert;
			baseVert++;
			countThisSpan--;
		}
		else
		{
			v[i] = baseVert;
			if ( countThisSpan > 1 )
			{
				countThisSpan--;
				baseVert++;
			}
		}
	}
	m_vertCache[m_cacheCount-1].LoadAndSwizzleAligned( pVerts[v[0]].Base(), pVerts[v[1]].Base(), pVerts[v[2]].Base(), pVerts[v[3]].Base() );
	FourVectors::RotateManyBy( &m_vertCache[0], m_cacheCount, *((const matrix3x4_t *)&m_ivpLocalToHLWorld) );

	return true;
}

bool CTraceIVP::BuildLeafmapCache( const leafmap_t * RESTRICT pLeafmap )
{
#if !USE_VERT_CACHE
	return false;
#else
	if ( !pLeafmap || !pLeafmap->HasSpans() || m_bHasTranslation )
		return false;
	if ( pLeafmap->HasRLESpans() )
	{
		return BuildLeafmapCacheRLE(pLeafmap);
	}

	// single vertex span, just xform + copy

	// iterate the span of verts and output them to a buffer in post-transform space
	// just iterate the range if one is specified
	int startPoint = pLeafmap->startVert[0];
	int pointCount = pLeafmap->vertCount;
	m_cacheCount = (pointCount + 3)>>2;
	Assert(m_cacheCount>=0 && m_cacheCount<= (BRUTE_FORCE_VERT_COUNT/4));

	const VectorAligned * RESTRICT pVerts = (const VectorAligned *)&m_pLedge->get_point_array()[startPoint];
	for ( int i = 0; i < m_cacheCount-1; i++ )
	{
		m_vertCache[i].LoadAndSwizzleAligned( pVerts[0].Base(), pVerts[1].Base(), pVerts[2].Base(), pVerts[3].Base() );
		pVerts += 4;
	}

	int remIndex = (pointCount-1) & 3;
	int x0 = 0;
	int x1 = min(1,remIndex);
	int x2 = min(2,remIndex);
	int x3 = min(3,remIndex);
	m_vertCache[m_cacheCount-1].LoadAndSwizzleAligned( pVerts[x0].Base(), pVerts[x1].Base(), pVerts[x2].Base(), pVerts[x3].Base() );
	FourVectors::RotateManyBy( &m_vertCache[0], m_cacheCount, *((const matrix3x4_t *)&m_ivpLocalToHLWorld) );
	return true;
#endif
}

static const fltx4 g_IndexBase = {0,1,2,3};
int CTraceIVP::SupportMapCached( const Vector &dir, Vector *pOut ) const
{
	VPROF("SupportMapCached");
#if USE_VERT_CACHE
	FourVectors fourDir;
#if defined(_X360)
	fltx4 vec = LoadUnaligned3SIMD( dir.Base() );
	fourDir.x = SplatXSIMD(vec);
	fourDir.y = SplatYSIMD(vec);
	fourDir.z = SplatZSIMD(vec);
#else
	fourDir.DuplicateVector(dir);
#endif

	fltx4 index = g_IndexBase;
	fltx4 maxIndex = g_IndexBase;
	fltx4 maxDot = fourDir * m_vertCache[0];
	for ( int i = 1; i < m_cacheCount; i++ )
	{
		index = AddSIMD(index, Four_Fours);
		fltx4 dot = fourDir * m_vertCache[i];
		fltx4 cmpMask = CmpGtSIMD(dot,maxDot);
		maxIndex = MaskedAssign( cmpMask, index, maxIndex );
		maxDot = MaxSIMD(dot, maxDot);
	}

	// find highest of 4
	fltx4 rot = RotateLeft2(maxDot);
	fltx4 rotIndex = RotateLeft2(maxIndex);
	fltx4 cmpMask = CmpGtSIMD(rot,maxDot);
	maxIndex = MaskedAssign(cmpMask, rotIndex, maxIndex);
	maxDot = MaxSIMD(rot,maxDot);
	rotIndex = RotateLeft(maxIndex);
	rot = RotateLeft(maxDot);
	cmpMask = CmpGtSIMD(rot,maxDot);
	maxIndex = MaskedAssign(cmpMask, rotIndex, maxIndex);
	// not needed unless we need the actual max dot at the end
	//	maxDot = MaxSIMD(rot,maxDot);

	int bestIndex = SubFloatConvertToInt(maxIndex,0);
	*pOut = CachedVertByIndex(bestIndex);

	return bestIndex;
#else
	Assert(0);
#endif
}

int CTraceIVP::SupportMap( const Vector &dir, Vector *pOut ) const
{
#if USE_VERT_CACHE
	if ( m_cacheCount )
		return SupportMapCached( dir, pOut );
#endif

	if ( m_pLeafmap && m_pLeafmap->HasSingleVertexSpan() )
	{
		VPROF("SupportMap_Leaf");
		const IVP_U_Float_Point *pPoints = m_pLedge->get_point_array();
		IVP_U_Float_Point mapdir;
		TransformDirectionToLocal( dir, mapdir );
		// just iterate the range if one is specified
		int startPoint = m_pLeafmap->startVert[0];
		int pointCount = m_pLeafmap->vertCount;
		float bestDot = pPoints[startPoint].dot_product(&mapdir);
		int best = startPoint;
		for ( int i = 1; i < pointCount; i++ )
		{
			float dot = pPoints[startPoint+i].dot_product(&mapdir);
			if ( dot > bestDot )
			{
				bestDot = dot;
				best = startPoint+i;
			}
		}

		TransformPositionFromLocal( pPoints[best], *pOut ); // transform point position to world space
		return best;
	}
	else
	{
		VPROF("SupportMap_Walk");
		const IVP_U_Float_Point *pPoints = m_pLedge->get_point_array();
		IVP_U_Float_Point mapdir;
		TransformDirectionToLocal( dir, mapdir );
		int triCount = m_pLedge->get_n_triangles();
		Assert( m_pVisitHash );
		m_pVisitHash->NewVisit();

		float dot;
		int triIndex = 0, edgeIndex = 0;
		GetStartVert( m_pLeafmap, mapdir, triIndex, edgeIndex );
		const IVP_Compact_Triangle *RESTRICT pTri = m_pLedge->get_first_triangle() + triIndex;
		const IVP_Compact_Edge *RESTRICT pEdge = pTri->get_edge( edgeIndex );
		int best = pEdge->get_start_point_index();
		float bestDot = pPoints[best].dot_product( &mapdir );
		m_pVisitHash->VisitVert(best);

		// This should never happen.  MAX_CONVEX_VERTS is very large (millions), none of our
		// models have anywhere near this many verts in a convex piece
		Assert(triCount*3<MAX_CONVEX_VERTS);
		// this loop will early out, but keep it from being infinite
		for ( int i = 0; i < triCount; i++ )
		{
			// get the index to the end vert of this edge (start vert on next edge)
			pEdge = pEdge->get_prev();
			int stopVert = pEdge->get_start_point_index();

			// loop through the verts that can be reached along edges from this vert
			// stop if you get back to the one you're starting on.
			int vert = stopVert;
			do
			{
				if ( !m_pVisitHash->WasVisited(vert) )
				{
					// this lets us skip doing dot products on this vert
					m_pVisitHash->VisitVert(vert);
					dot = pPoints[vert].dot_product( &mapdir );
					if ( dot > bestDot )
					{
						bestDot = dot;
						best = vert;
						break;
					}
				}
				// tri opposite next edge, same starting vert as next edge
				pEdge = pEdge->get_opposite()->get_prev();
				vert = pEdge->get_start_point_index();
			} while ( vert != stopVert );

			// if you exhausted the possibilities for this vert, it must be the best vert
			if ( vert != best )
				break;
		}

		// code to do the brute force method with no hill-climbing
#if 0
		for ( i = 0; i < triCount; i++ )
		{
			pTri = m_pLedge->get_first_triangle() + i;
			for ( int j = 0; j < 3; j++ )
			{
				pEdge = pTri->get_edge( j );
				int test = pEdge->get_start_point_index();
				dot = pPoints[test].dot_product( &mapdir );
				if ( dot > bestDot )
				{
					Assert(0);		// shouldn't hit this unless the hill-climb is broken
					bestDot = dot;
					best = test;
				}
			}
		}
#endif
		TransformPositionFromLocal( pPoints[best], *pOut ); // transform point position to world space

		return best;
	}
}

Vector CTraceIVP::GetVertByIndex( int index ) const
{
#if USE_VERT_CACHE
	if ( m_cacheCount )
	{
		return CachedVertByIndex(index);
	}
#endif
	const IVP_Compact_Poly_Point *pPoints = m_pLedge->get_point_array();

	Vector out;
	TransformPositionFromLocal( pPoints[index], out );
	return out;
}

//-----------------------------------------------------------------------------
// Purpose: Implementation for Trace against an AABB
//-----------------------------------------------------------------------------
class CTraceAABB : public ITraceObject
{
public:
	CTraceAABB( const Vector &hlmins, const Vector &hlmaxs, bool isPoint );
	virtual int SupportMap( const Vector &dir, Vector *pOut ) const;
	virtual Vector GetVertByIndex( int index ) const;
	virtual float Radius( void ) const { return m_radius; }

private:
	float	m_x[2];
	float	m_y[2];
	float	m_z[2];
	float	m_radius;
	bool	m_empty;
};


CTraceAABB::CTraceAABB( const Vector &hlmins, const Vector &hlmaxs, bool isPoint )
{
	if ( isPoint )
	{
		m_x[0] = m_x[1] = 0;
		m_y[0] = m_y[1] = 0;
		m_z[0] = m_z[1] = 0;
		m_radius = 0;
		m_empty = true;
	}
	else
	{
		m_x[0] = hlmaxs[0];
		m_x[1] = hlmins[0];
		m_y[0] = hlmaxs[1];
		m_y[1] = hlmins[1];
		m_z[0] = hlmaxs[2];
		m_z[1] = hlmins[2];
		m_radius = hlmaxs.Length();
		m_empty = false;
	}
}


int CTraceAABB::SupportMap( const Vector &dir, Vector *pOut ) const
{
	Vector out;

	if ( m_empty )
	{
		pOut->Init();
		return 0;
	}
	// index is formed by the 3-bit bitfield SzSySx (negative is 1, positive is 0)
	int x = ((*((unsigned int *)&dir.x)) & 0x80000000UL) >> 31;
	int y = ((*((unsigned int *)&dir.y)) & 0x80000000UL) >> 31;
	int z = ((*((unsigned int *)&dir.z)) & 0x80000000UL) >> 31;
	pOut->x = m_x[x];
	pOut->y = m_y[y];
	pOut->z = m_z[z];
	return (z<<2) | (y<<1) | x;
}

Vector CTraceAABB::GetVertByIndex( int index ) const
{
	Vector out;
	out.x = m_x[(index&1)];
	out.y = m_y[(index&2)>>1];
	out.z = m_z[(index&4)>>2];

	return out;
}


//-----------------------------------------------------------------------------
// Purpose: Implementation for Trace against an IVP object
//-----------------------------------------------------------------------------
class CTraceRay
{
public:
	CTraceRay( const Vector &hlstart, const Vector &hlend );
	CTraceRay( const Ray_t &ray );
	CTraceRay( const Ray_t &ray, const Vector &offset );
	void Init( const Vector &hlstart, const Vector &delta );
	int SupportMap( const Vector &dir, Vector *pOut ) const;
	Vector GetVertByIndex( int index ) const { return ( index ) ? m_end : m_start; }
	float Radius( void ) const { return m_length * 0.5f; }

	void Reset( float fraction );

	Vector	m_start;
	Vector	m_end;
	Vector	m_delta;
	Vector	m_dir;

	float	m_length;
	float	m_baseLength;
	float	m_ooBaseLength;
	float	m_bestDist;
};
CTraceRay::CTraceRay( const Vector &hlstart, const Vector &hlend )
{
	Init(hlstart, hlend-hlstart);
}

void CTraceRay::Init( const Vector &hlstart, const Vector &delta )
{
	m_start = hlstart;
	m_end = hlstart + delta;
	m_delta = delta;
	m_dir = delta;
	float len = DotProduct(delta, delta);
	// don't use fast/sse sqrt here we need the precision
	m_length = sqrt(len);
	m_ooBaseLength = 0.0f;
	if ( m_length > 0 )
	{
		m_ooBaseLength = 1.0f / m_length;
		m_dir *= m_ooBaseLength;
	}
	m_baseLength = m_length;
	m_bestDist = 0.f;
}

CTraceRay::CTraceRay( const Ray_t &ray )
{
	Init( ray.m_Start, ray.m_Delta );
}

CTraceRay::CTraceRay( const Ray_t &ray, const Vector &offset )
{
	Vector start;
	VectorAdd( ray.m_Start, offset, start );
	Init( start, ray.m_Delta );
}

void CTraceRay::Reset( float fraction )
{
	// recompute from base values for max precision
	m_length = m_baseLength * fraction;
	m_end = m_start + fraction * m_delta;
	m_bestDist = 0.f;
}

int CTraceRay::SupportMap( const Vector &dir, Vector *pOut ) const
{
	if ( DotProduct( dir, m_delta ) > 0 )
	{
		*pOut = m_end;
		return 1;
	}
	*pOut = m_start;
	return 0;
}

static char			*map_nullname = "**empty**";
static csurface_t	nullsurface = { map_nullname, 0 };

static void CM_ClearTrace( trace_t *trace )
{
	memset( trace, 0, sizeof(*trace));
	trace->fraction = 1.f;
	trace->fractionleftsolid = 0;
	trace->surface = nullsurface;
}

class CDefConvexInfo : public IConvexInfo
{
public:
	IConvexInfo *GetPtr() { return this; }

	virtual unsigned int GetContents( int convexGameData ) { return CONTENTS_SOLID; }
};

class CTraceSolver
{
public:
	CTraceSolver( trace_t *ptr, ITraceObject *sweepobject, CTraceRay *ray, ITraceObject *obstacle, const Vector &axis )
	{
		m_pTotalTrace = ptr;
		m_sweepObject = sweepobject;
		m_sweepObjectRadius = m_sweepObject->Radius();
		m_obstacle = obstacle;
		m_ray = ray;
		m_traceLength = 0;
		m_totalTraceLength = max( ray->m_baseLength, 1e-8f );
		m_pointClosestToIntersection = axis;
		m_epsilon = g_PhysicsUnits.collisionSweepEpsilon;
	}

	bool SweepSingleConvex( void );
	float SolveMeshIntersection( simplex_t &simplex );
	float SolveMeshIntersection2D( simplex_t &simplex );
	virtual void DoSweep( void )
	{
		SweepSingleConvex();
		*m_pTotalTrace = m_trace;
	}


	void SetEpsilon( float epsilon )
	{
		m_epsilon = epsilon;
	}

protected:
	trace_t				m_trace;

	Vector				m_pointClosestToIntersection;
	ITraceObject		*m_sweepObject;
	ITraceObject		*m_obstacle;
	CTraceRay			*m_ray;
	trace_t				*m_pTotalTrace;
	float				m_traceLength;
	float				m_totalTraceLength;
	float				m_sweepObjectRadius;
	float				m_epsilon;
private:
	CTraceSolver( const CTraceSolver & );
};

class CTraceSolverSweptObject : public CTraceSolver
{
public:
	CTraceSolverSweptObject( trace_t *ptr, ITraceObject *sweepobject, CTraceRay *ray, CTraceIVP *obstacle, const Vector &axis, unsigned int contentsMask, IConvexInfo *pConvexInfo );

	void InitOSRay( void );
	void SweepLedgeTree_r( const IVP_Compact_Ledgetree_Node *node );
	inline bool SweepHitsSphereOS( const IVP_U_Float_Point *sphereCenter, float radius );
	virtual void DoSweep( void );
	inline void SweepAgainstNode( const IVP_Compact_Ledgetree_Node *node );

	CTraceIVP			*m_obstacleIVP;
	IConvexInfo			*m_pConvexInfo;
	unsigned int		m_contentsMask;
	CDefConvexInfo		m_fakeConvexInfo;


	IVP_U_Float_Point	m_rayCenterOS;
	IVP_U_Float_Point	m_rayStartOS;
	IVP_U_Float_Point	m_rayDirOS;
	IVP_U_Float_Point	m_rayDeltaOS;
	float				m_rayLengthOS;

private:
	CTraceSolverSweptObject( const CTraceSolverSweptObject & ); // no implementation, quells compiler warning
};

CTraceSolverSweptObject::CTraceSolverSweptObject( trace_t *ptr, ITraceObject *sweepobject, CTraceRay *ray, CTraceIVP *obstacle, const Vector &axis, unsigned int contentsMask, IConvexInfo *pConvexInfo )
: CTraceSolver( ptr, sweepobject, ray, obstacle, axis )
{
	m_obstacleIVP = obstacle;
	m_contentsMask = contentsMask;
	m_pConvexInfo = (pConvexInfo != NULL) ? pConvexInfo : m_fakeConvexInfo.GetPtr();
}


bool CTraceSolverSweptObject::SweepHitsSphereOS( const IVP_U_Float_Point *sphereCenter, float radius )
{
	// disable this to help find bugs
#if DEBUG_TEST_ALL_LEDGES
	return true;
#endif
	// the ray is actually a line-swept-sphere with sweep object's radius
	IVP_U_Float_Point delta_vec; // quick check for ends of ray
	delta_vec.subtract( sphereCenter, &m_rayCenterOS );
	radius += m_sweepObjectRadius;
	// Is the sphere close enough to the ray at the center?
	float qsphere_rad = radius * radius;

	// If this is a 0 length ray, then the conservative test is 100% accurate
	if ( m_rayLengthOS > 0 )
	{
		// Calculate the perpendicular distance to the sphere 
		// The perpendicular forms a right triangle with the vector between the ray/sphere centers
		// and the ray direction vector.  Calculate the projection of the hypoteneuse along the perpendicular
		IVP_U_Float_Point h;
		h.inline_calc_cross_product(&m_rayDirOS, &delta_vec);

		if( h.quad_length() < qsphere_rad )
			return true;
	}
	else
	{
		float quad_center_dist = delta_vec.quad_length();

		if ( quad_center_dist < qsphere_rad )
		{
			return true;
		}

		// Could a ray in any direction away from the ray center intersect this sphere?
		float qrad_sum = m_rayLengthOS * 0.5f + radius;
		qrad_sum *= qrad_sum;
		if ( quad_center_dist >= qrad_sum )
		{
			return false;
		}
	}

	return false;
}

inline void CTraceSolverSweptObject::SweepAgainstNode(const IVP_Compact_Ledgetree_Node *node)
{
	const IVP_Compact_Ledge *ledge = node->get_compact_ledge();
	unsigned int ledgeContents = m_pConvexInfo->GetContents( ledge->get_client_data() );
	if (m_contentsMask & ledgeContents)
	{
		m_obstacleIVP->SetLedge( ledge );
		if ( SweepSingleConvex() )
		{
			if ( m_traceLength < m_totalTraceLength )
			{
				m_pTotalTrace->plane.normal = m_trace.plane.normal;
				m_pTotalTrace->startsolid = m_trace.startsolid;
				m_pTotalTrace->allsolid = m_trace.allsolid;
				m_totalTraceLength = m_traceLength;
				m_pTotalTrace->fraction = m_traceLength * m_ray->m_ooBaseLength;
				Assert(m_pTotalTrace->fraction >= 0 && m_pTotalTrace->fraction <= 1.0f);
#if !DEBUG_KEEP_FULL_RAY
				// shrink the ray to the shortened length, but leave a buffer of collisionSweepEpsilon units
				// at the end to make sure that precision doesn't make you miss something slightly closer
				float testFraction = (m_traceLength + m_epsilon*2) * m_ray->m_ooBaseLength;
				if ( testFraction < 1.0f )
				{
					m_ray->Reset( testFraction );
					// Update OS ray to limit tests
					m_rayLengthOS = m_obstacleIVP->TransformLengthToLocal( m_ray->m_length );
					m_rayCenterOS.add_multiple( &m_rayStartOS, &m_rayDeltaOS, 0.5f * testFraction );
				}
#endif
				m_pTotalTrace->contents = ledgeContents;
			}
		}
	}
}


void CTraceSolverSweptObject::SweepLedgeTree_r( const IVP_Compact_Ledgetree_Node *node )
{
	IVP_U_Float_Point center; 
	center.set(node->center.k);
	if ( !SweepHitsSphereOS( &center, node->radius ) )
		return;

	// fast path for single leaf collision models
	if ( node->is_terminal() == IVP_TRUE )
	{
		SweepAgainstNode(node);
		return;
	}

	// use an array to implement a simple stack
	CUtlVectorFixedGrowable<const IVP_Compact_Ledgetree_Node *, 64> list;

	// pull the last item in the array (top of stack)
	// this is nearly a priority queue, but not actually, but it's cheaper (and faster in the benchmarks)
	// this code is trying to visit the nodes closest to the ray start first - which helps performance
	// since we're only interested in the first intersection of the swept object with the physcollide.
	while ( 1 )
	{
		// don't use the temp storage unless you have to.
loop_without_store:
		if ( node->is_terminal() == IVP_TRUE )
		{
			// leaf, do the test
			SweepAgainstNode(node);
		}
		else
		{
			// check node's children
			const IVP_Compact_Ledgetree_Node *node0 = node->left_son();
			center.set(node0->center.k);
			// if we don't insert, this is larger than any quad distance
			float lastDist = 1e24f;
			if ( SweepHitsSphereOS( &center, node0->radius ) )
			{
				lastDist = m_rayStartOS.quad_distance_to(&center);
			}
			else
			{
				node0 = NULL;
			}
			const IVP_Compact_Ledgetree_Node *node1 = node->right_son();
			center.set(node1->center.k);
			if ( SweepHitsSphereOS( &center, node1->radius ) )
			{
				if ( node0 )
				{
					// can hit, push on stack
					int index = list.AddToTail();
					float dist1 = m_rayStartOS.quad_distance_to(&center);
					if ( lastDist < dist1 )
					{
						node = node0;
						list[index] = node1;
					}
					else
					{
						node = node1;
						list[index] = node0;
					}
				}
				else
				{
					node = node1;
				}
				goto loop_without_store;
			}
			if ( node0 )
			{
				node = node0;
				goto loop_without_store;
			}
		}
		int last = list.Count()-1;
		if ( last < 0 )
			break;
		node = list[last];
		list.FastRemove(last);
	}
}


void CTraceSolverSweptObject::InitOSRay( void )
{
	// transform ray into object space
	m_rayLengthOS = m_obstacleIVP->TransformLengthToLocal( m_ray->m_length );
	m_obstacleIVP->TransformPositionToLocal( m_ray->m_start, m_rayStartOS );

	// no translation on matrix mult because this is a vector
	m_obstacleIVP->RotateRelativePositionToLocal( m_ray->m_delta, m_rayDeltaOS );
	m_rayDirOS.set(&m_rayDeltaOS);
	m_rayDirOS.normize();

	// add_multiple with 3 params assumes no initial value (should be set_add_multiple)
	m_rayCenterOS.add_multiple( &m_rayStartOS, &m_rayDeltaOS, 0.5f );
}


void CTraceSolverSweptObject::DoSweep( void )
{
	VPROF("TraceSolver::DoSweep");
	InitOSRay();

	// iterate ledge tree of obstacle
	const IVP_Compact_Surface *pSurface = m_obstacleIVP->m_pSurface;

	const IVP_Compact_Ledgetree_Node *lt_node_root;
	lt_node_root = pSurface->get_compact_ledge_tree_root();
	SweepLedgeTree_r( lt_node_root );
}

void CPhysicsTrace::SweepBoxIVP( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, const CPhysCollide *pCollide, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr )
{
	Ray_t ray;
	ray.Init( start, end, mins, maxs );
	SweepBoxIVP( ray, MASK_ALL, NULL, pCollide, surfaceOrigin, surfaceAngles, ptr );
}

void CPhysicsTrace::SweepBoxIVP( const Ray_t &raySrc, unsigned int contentsMask, IConvexInfo *pConvexInfo, const CPhysCollide *pCollide, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr )
{
	CM_ClearTrace( ptr );

	CTraceAABB box( -raySrc.m_Extents, raySrc.m_Extents, raySrc.m_IsRay );
	CTraceIVP ivp( pCollide, vec3_origin, surfaceAngles );

	// offset the space of this sweep so that the surface is at the origin of the solution space
	CTraceRay ray( raySrc, -surfaceOrigin );

	CTraceSolverSweptObject solver( ptr, &box, &ray, &ivp, ray.m_start, contentsMask, pConvexInfo );
	solver.DoSweep();

	VectorAdd( raySrc.m_Start, raySrc.m_StartOffset, ptr->startpos );
	VectorMA( ptr->startpos, ptr->fraction, raySrc.m_Delta, ptr->endpos );
	// The plane was shifted because we shifted everything over by surfaceOrigin, shift it back
	if ( ptr->DidHit() )
	{
		ptr->plane.dist = DotProduct( ptr->endpos, ptr->plane.normal );
	}
}

void CPhysicsTrace::SweepIVP( const Vector &start, const Vector &end, const CPhysCollide *pSweptSurface, const QAngle &sweptAngles, const CPhysCollide *pSurface, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr )
{
	CM_ClearTrace( ptr );

	CTraceIVP sweptObject( pSweptSurface, vec3_origin, sweptAngles );

	// offset the space of this sweep so that the surface is at the origin of the solution space
	CTraceIVP ivp( pSurface, vec3_origin, surfaceAngles );
	CTraceRay ray( start - surfaceOrigin, end - surfaceOrigin );

	IVP_U_BigVector<IVP_Compact_Ledge> objectLedges(32);
	IVP_Compact_Ledge_Solver::get_all_ledges( pSweptSurface->GetCompactSurface(), &objectLedges );
	for ( int i = objectLedges.len() - 1; i >= 0; --i )
	{
		trace_t tr;
		CM_ClearTrace( &tr );
		sweptObject.SetLedge( objectLedges.element_at(i) );
		CTraceSolverSweptObject solver( &tr, &sweptObject, &ray, &ivp, start - surfaceOrigin, MASK_ALL, NULL );
		// UNDONE: Need just more than 0.25" tolerance here because the output position will be used by vphysics
		// UNDONE: Really this should be the collision radius from the environment.
		solver.SetEpsilon( g_PhysicsUnits.globalCollisionTolerance );
		solver.DoSweep();
		if ( tr.fraction < ptr->fraction )
		{
			*ptr = tr;
		}
	}
	ptr->endpos = start*(1.f-ptr->fraction) + end * ptr->fraction;
	if ( ptr->DidHit() )
	{
		ptr->plane.dist = DotProduct( ptr->endpos, ptr->plane.normal );
	}
}


static void CalculateSeparatingPlane( trace_t *ptr, ITraceObject *sweepObject, CTraceRay *ray, ITraceObject *obstacle, simplex_t &simplex );


//-----------------------------------------------------------------------------
// What is this doing? It's going to be hard to understand without reading a 
// reference on the GJK algorithm.  But here's a quick overview:
// Basically (remember this is glossing over a ton of details!) the 
// algorithm is building up a simplex that is trying to contain the origin.  
// A simplex is a point, line segment, triangle, or tetrahedron - depending on 
// how many verts you have.  
// Anyway it slowly builds one of these one vert at a time with a directed search. 
// So you start out with a point, then it guesses the next point that would be 
// most likely to form a line through the origin.  If the line doesn't go quite 
// through the origin it tries to find a third point to capture the origin 
// within a triangle.  If that doesn't work it tries to make a 
// tent (tetrahedron) out of the triangle to capture the origin.
//
// But at each step if the origin is not contained within, it tries to 
// find which sub-feature is most likely to be in the solution.  In 
// the point case it's always just the point.  In the line/edge case it 
// can reduce back to a point (origin is closest to one of the points) 
// or be the line (origin is closest to some point between them).  
// Same with the triangle (origin is closest to one vert - vert, origin is 
// closest to one edge - reduce to that edge, origin is closes to some point 
// in the triangle's surface - keep the whole triangle).  With a tetrahedron 
// keeping the whole isn't possible unless the origin is inside and you're 
// done (the origin has been captured).
//
// "You're done"  means that there is an intersection between the two 
// volumes.  Assuming you're testing a sweep, it still has to test whether that 
// sweep can be shrunk back until there is no intersection.  So it checks that.
// If it's a swept test so it does the search with SolveMeshIntersection
// Otherwise, there's nothing to shrink, so you set startsolid and allsolid 
// because it's a point/box in solid test, not a swept box/ray hits solid test.
//
// Why is it trying to capture the origin? Basically GJK sets up a space 
// and a convex hull (the minkowski sum) in that space.  The convex hull
// represents a field of the distances between different features of the pair
// of objects (e.g. for two circles, this minkowski sum is just a circle).  
// So the origin is the point in the field where the distance between the 
// objects is zero.  This means they intersect.
//-----------------------------------------------------------------------------
#if defined(_X360)
inline void VectorNormalize_FastLowPrecision( Vector &a ) 
{
	float quad = (a.x*a.x) + (a.y*a.y) + (a.z*a.z);
	float ilen = __frsqrte(quad);
	a.x *= ilen;
	a.y *= ilen;
	a.z *= ilen;
}
#else
#define VectorNormalize_FastLowPrecision VectorNormalize
#endif

bool CTraceSolver::SweepSingleConvex( void )
{
	VPROF("TraceSolver::SweepSingleConvex");
	simplex_t simplex;
	simplexvert_t	vert;
	Vector tmp;

	simplex.vertCount = 0;

	if ( m_pointClosestToIntersection == vec3_origin )
	{
		m_pointClosestToIntersection.Init(1,0,0);
	}

	float testLen = 1;
	Vector dir = -m_pointClosestToIntersection;
	VectorNormalize_FastLowPrecision(dir);
	// safe loop, max 100 iterations
	for ( int i = 0; i < 100; i++ )
	{
		// map the direction into the minkowski sum, get a new surface point
		vert.testIndex = m_sweepObject->SupportMap( dir, &vert.position );
		vert.sweepIndex = m_ray->SupportMap( dir, &tmp );
		VectorAdd( vert.position, tmp, vert.position );
		vert.obstacleIndex = m_obstacle->SupportMap( -dir, &tmp );
		VectorSubtract( vert.position, tmp, vert.position );

		testLen = DotProduct( dir, vert.position );
		// found a separating axis, no intersection
		if ( testLen < 0 )
		{
			VPROF("SolveSeparation");
			// make sure we're separated by at least m_epsilon
			testLen = fabs(testLen);
			if ( testLen < m_epsilon && m_ray->m_length > 0 )
			{
				// not separated by enough
				Vector normal = dir;
				if ( testLen > 0 )
				{
					// try to find a better separating plane or clip the ray to the current one
					for ( int j = 0; j < 20; j++ )
					{
						Vector lastVert = vert.position;
						simplex.SolveGJKSet( vert, &m_pointClosestToIntersection );
						dir = -m_pointClosestToIntersection;
						VectorNormalize_FastLowPrecision( dir );
						// map the direction into the minkowski sum, get a new surface point
						vert.testIndex = m_sweepObject->SupportMap( dir, &vert.position );
						vert.sweepIndex = m_ray->SupportMap( dir, &tmp );
						VectorAdd( vert.position, tmp, vert.position );
						vert.obstacleIndex = m_obstacle->SupportMap( -dir, &tmp );
						VectorSubtract( vert.position, tmp, vert.position );

						// found a separating axis, no intersection
						float est = -DotProduct( dir, vert.position );
						if ( est > m_epsilon ) // big enough separation, no hit
							return false;
						// take plane with the most separation
						if ( est > testLen )
						{
							testLen = est;
							normal = dir;
						}
						float last = -DotProduct( dir, lastVert );
						// search is not converging, exit.
						if ( (est - last) > -1e-4f )
							break;
					}
				}

				// This trace is going to miss, but not by enough.
				// Hit the separating plane instead 
				float dot = -DotProduct( m_ray->m_delta, normal );
				if ( dot < -(m_epsilon*0.1) || (dot < -1e-4f && testLen < (m_epsilon*0.9)) )
				{
					CM_ClearTrace( &m_trace );
					float backupDistance = m_epsilon - testLen;
					backupDistance = -(backupDistance * m_ray->m_baseLength) / dot;
					m_traceLength = m_ray->m_length - backupDistance;
					if ( m_traceLength < 0 )
					{
						m_traceLength = 0;
						// try sliding along the surface of the minkowski sum
						backupDistance = SolveMeshIntersection2D( simplex );
						if ( m_ray->m_length > backupDistance )
						{
							m_traceLength = m_ray->m_length - backupDistance;
						}
					}
					m_trace.plane.normal = -normal;
					// this is fixed up by the outer code
					//m_trace.endpos = m_ray->m_start*(1.f-m_trace.fraction) + m_ray->m_end*m_trace.fraction;
					m_trace.contents = CONTENTS_SOLID;
					return true;
				}
			}
			return false;
		}

		// contains the origin
		if ( simplex.SolveGJKSet( vert, &m_pointClosestToIntersection ) )
		{
			VPROF("TraceSolver::SolveMeshIntersection");
			CM_ClearTrace( &m_trace );
			// now solve for t along the sweep
			if ( m_ray->m_length != 0 )
			{
				float dist = SolveMeshIntersection( simplex );
				if ( dist < m_ray->m_length && dist > 0.f )
				{
					m_traceLength = (m_ray->m_length - dist);
					CalculateSeparatingPlane( &m_trace, m_sweepObject, m_ray, m_obstacle, simplex );
					float dot = DotProduct( m_ray->m_dir, m_trace.plane.normal );
					if ( dot < 0 )
					{
						m_traceLength += (m_epsilon / dot);
					}

					if ( m_traceLength < 0 )
					{
						m_traceLength = 0;
					}
					//m_trace.fraction = m_traceLength * m_ray->m_ooBaseLength;
					//m_trace.endpos = m_ray->m_start*(1.f-m_trace.fraction) + m_ray->m_end*m_trace.fraction;
					m_trace.contents = CONTENTS_SOLID;
				}
				else
				{
					// UNDONE: This case happens when you start solid as well as when a false 
					// intersection is detected at the very end of the trace
					m_trace.startsolid = true;
					m_trace.allsolid = true;
					m_traceLength = 0;
				}
			}
			else
			{
				m_trace.startsolid = true;
				m_trace.allsolid = true;
				m_traceLength = 0;
			}
			return true;
		}
		dir = -m_pointClosestToIntersection;
		VectorNormalize_FastLowPrecision( dir );
	}

	// BUGBUG: The solution never converged - something is probably wrong!
	AssertMsg( false, "Solution never converged.");
	return false;
}


// NEW SWEPT GJK SOLVER 2/16/2006
// convenience routines - just makes the code a little simpler.
FORCEINLINE bool simplex_t::TriangleSimplex( const simplexvert_t &newPoint, int outIndex, const Vector &faceNormal, Vector *pOut )
{
	vertCount = 3;
	verts[outIndex] = newPoint;
	*pOut = -faceNormal;
	return false;
}
FORCEINLINE bool simplex_t::EdgeSimplex( const simplexvert_t &newPoint, int outIndex, const Vector &edge, Vector *pOut )
{
	vertCount = 2;
	verts[outIndex] = newPoint;
	Vector cross;
	CrossProduct( edge, newPoint.position, cross );
	CrossProduct( cross, edge, *pOut );
	return false;
}

FORCEINLINE bool simplex_t::PointSimplex( const simplexvert_t &newPoint, Vector *pOut )
{
	vertCount = 1;
	verts[0] = newPoint;
	*pOut = newPoint.position;
	return false;
}

// In general the voronoi region routines have comments referring to the verts
// All of the code assumes that vert A is the new vert being added to the set
// verts B, C, D are the previous set.  If BCD is a triangle it is assumed to be
// counter-clockwise winding order.  This must be maintained by the code!

// parametric value for closes point on a line segment (p0->p1) to the origin.
bool simplex_t::SolveVoronoiRegion2( const simplexvert_t &newPoint, Vector *pOut )
{
	// solve the line segment AB (where A is the new point)
	Vector AB = verts[0].position - newPoint.position;
	float d = DotProduct(AB, newPoint.position);
	if ( d < 0 )
	{
		return EdgeSimplex(newPoint, 1, AB, pOut);
	}
	else
	{
		return PointSimplex(newPoint, pOut);
	}
}

// UNDONE: Collapse these routines into a single general routine?
bool simplex_t::SolveVoronoiRegion3( const simplexvert_t &newPoint, Vector *pOut )
{
	// solve the triangle ABC (where A is the new point)
	Vector AB = verts[0].position - newPoint.position;
	Vector AC = verts[1].position - newPoint.position;
	Vector ABC;
	CrossProduct(AB, AC, ABC);
	Vector ABCxAC;
	CrossProduct(ABC, AC, ABCxAC);
	float d = DotProduct(ABCxAC, newPoint.position);
	// edge AC or edgeAB / A?
	if ( d < 0 )
	{
		d = DotProduct(AC, newPoint.position);
		if ( d < 0 )
		{
			// edge AC
			return EdgeSimplex(newPoint, 0, AC, pOut);
		}
	}
	else
	{
		// face or A / edge AB?
		Vector ABxABC;
		CrossProduct(AB, ABC, ABxABC);
		d = DotProduct(ABxABC, newPoint.position);
		if ( d > 0 )
		{
			// closest to face
			vertCount = 3;
			d = DotProduct(ABC, newPoint.position);
			// in front of face, return opposite direction
			if ( d < 0 )
			{
				verts[2] = newPoint;
				*pOut = -ABC;
				return false;
			}
			verts[2] = verts[1]; // swap to keep CCW
			verts[1] = newPoint;
			*pOut = ABC;
			return false;
		}
	}
	// edge AB or A
	d = DotProduct(AB, newPoint.position);
	if ( d < 0 )
	{
		return EdgeSimplex(newPoint, 1, AB, pOut);
	}
	return PointSimplex(newPoint, pOut);
}

bool simplex_t::SolveVoronoiRegion4( const simplexvert_t &newPoint, Vector *pOut )
{
	// solve the tetrahedron ABCD (where A is the new point)

	// compute edge vectors
	Vector AB = verts[0].position - newPoint.position;
	Vector AC = verts[1].position - newPoint.position;
	Vector AD = verts[2].position - newPoint.position;

	// compute face normals
	Vector ABC, ACD, ADB;
	CrossProduct( AB, AC, ABC );
	CrossProduct( AC, AD, ACD );
	CrossProduct( AD, AB, ADB );

	// edge plane normals
	Vector ABCxAC, ABxABC;
	CrossProduct( ABC, AC, ABCxAC );
	CrossProduct( AB, ABC, ABxABC );
	Vector ACDxAD, ACxACD;
	CrossProduct( ACD, AD, ACDxAD );
	CrossProduct( AC, ACD, ACxACD );
	Vector ADBxAB, ADxADB;
	CrossProduct( ADB, AB, ADBxAB );
	CrossProduct( AD, ADB, ADxADB );

	int faceFlags = 0;
	float d;
	d = DotProduct(ABC,newPoint.position);
	if ( d < 0 )
	{
		faceFlags |= 0x1;
	}
	d = DotProduct(ACD,newPoint.position);
	if ( d < 0 )
	{
		faceFlags |= 0x2;
	}
	d = DotProduct(ADB,newPoint.position);
	if ( d < 0 )
	{
		faceFlags |= 0x4;
	}

	switch( faceFlags )
	{
	case 0:
		// inside all 3 faces, we're done
		verts[3] = newPoint;
		vertCount = 4;
		return true;
	case 1:
		// ABC only, solve as a triangle
		return SolveVoronoiRegion3(newPoint, pOut);
	case 2:
		// ACD only, solve as a triangle
		verts[0] = verts[2]; // collapse BCD to DC
		return SolveVoronoiRegion3(newPoint, pOut);
	case 4:
		// ADB only, solve as a triangle
		verts[1] = verts[2]; // collapse BCD to BD
		return SolveVoronoiRegion3(newPoint, pOut);
	case 3:
		{
			// in front of ABC & ACD
			d = DotProduct(ABCxAC, newPoint.position);
			if ( d < 0 )
			{
				d = DotProduct(ACxACD, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AC,newPoint.position);
					if ( d < 0 )
					{
						// edge AC
						return EdgeSimplex( newPoint, 0, AC, pOut);
					}
					// point A
					return PointSimplex(newPoint, pOut);
				}
				else
				{
					d = DotProduct(ACDxAD, newPoint.position);
					if ( d < 0 )
					{
						// edge AD
						verts[0] = verts[2]; // collapse BCD to D
						return EdgeSimplex(newPoint, 1, AD, pOut);
					}
					// face ACD
					return TriangleSimplex(newPoint,0,ACD, pOut);
				}
			}
			else
			{
				d = DotProduct(ABxABC, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AB, newPoint.position);
					if ( d < 0 )
					{
						// edge AB
						return EdgeSimplex(newPoint, 1, AB, pOut);
					}
					return PointSimplex(newPoint, pOut);
				}
				return TriangleSimplex(newPoint,2,ABC,pOut);
			}
		}
		break;
	case 5:
		{
			// in front of ADB & ABC
			d = DotProduct(ADBxAB, newPoint.position);
			if ( d < 0 )
			{
				d = DotProduct(ABxABC, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AB,newPoint.position);
					if ( d < 0 )
					{
						// edge AB
						return EdgeSimplex( newPoint, 1, AB , pOut);
					}
					// point A
					return PointSimplex(newPoint, pOut);
				}
				else
				{
					d = DotProduct(ABCxAC, newPoint.position);
					if ( d < 0 )
					{
						// edge AC
						return EdgeSimplex(newPoint, 0, AC, pOut);
					}
					// face ABC
					return TriangleSimplex(newPoint,2,ABC,pOut);
				}
			}
			else
			{
				d = DotProduct(ADxADB, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AD, newPoint.position);
					if ( d < 0 )
					{
						// edge AD
						verts[0] = verts[2]; // collapse BCD to D
						return EdgeSimplex(newPoint, 1, AD, pOut);
					}
					return PointSimplex(newPoint, pOut);
				}
				return TriangleSimplex(newPoint,1,ADB,pOut);
			}
		}
		break;
	case 6:
		{
			// in front of ACD & ADB
			d = DotProduct(ACDxAD, newPoint.position);
			if ( d < 0 )
			{
				d = DotProduct(ADxADB, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AD,newPoint.position);
					if ( d < 0 )
					{
						// edge AD
						verts[0] = verts[2]; // collapse BCD to D
						return EdgeSimplex(newPoint, 1, AD, pOut);
					}
					// point A
					return PointSimplex(newPoint, pOut);
				}
				else
				{
					d = DotProduct(ADBxAB, newPoint.position);
					if ( d < 0 )
					{
						// edge AB
						return EdgeSimplex(newPoint, 1, AB, pOut);
					}
					// face ADB
					return TriangleSimplex(newPoint,1,ADB, pOut);
				}
			}
			else
			{
				d = DotProduct(ACxACD, newPoint.position);
				if ( d < 0 )
				{
					d = DotProduct(AC, newPoint.position);
					if ( d < 0 )
					{
						// edge AC
						return EdgeSimplex(newPoint, 0, AC, pOut);
					}
					return PointSimplex(newPoint, pOut);
				}
				return TriangleSimplex(newPoint,0,ACD, pOut);
			}
		}
		break;
	case 7:
		{
			d = DotProduct(AB, newPoint.position);
			if ( d < 0 )
			{
				return EdgeSimplex(newPoint, 1, AB, pOut);
			}
			else
			{
				d = DotProduct(AC, newPoint.position);
				if ( d < 0 )
				{
					return EdgeSimplex(newPoint, 0, AC, pOut);
				}
				else
				{
					d = DotProduct(AD, newPoint.position);
					if ( d < 0 )
					{
						verts[0] = verts[2]; // collapse BCD to D
						return EdgeSimplex(newPoint, 1, AD, pOut);
					}
					return PointSimplex(newPoint, pOut);
				}
			}
		}
	}
	verts[3] = newPoint;
	vertCount = 4;
	return true;
}


bool simplex_t::SolveGJKSet( const simplexvert_t &w, Vector *pOut )
{
	VPROF("TraceSolver::simplex::SolveGJKSet");

#if 0
	for ( int v = 0; v < vertCount; v++ )
	{
		for ( int v2 = v+1; v2 < vertCount; v2++ )
		{
			if ( (verts[v].obstacleIndex == verts[v2].obstacleIndex) &&
				(verts[v].sweepIndex == verts[v2].sweepIndex) &&
				(verts[v].testIndex == verts[v2].testIndex) )
			{
				// same vert in the list twice!  degenerate
				Assert(0);
			}
		}
	}
#endif

	switch( vertCount )
	{
	case 0:
		vertCount = 1;
		verts[0] = w;
		*pOut = w.position;
		return false;
	case 1:
		return SolveVoronoiRegion2( w, pOut );
	case 2:
		return SolveVoronoiRegion3( w, pOut );
	case 3:
		return SolveVoronoiRegion4( w, pOut );
	}

	return true;
}


void CalculateSeparatingPlane( trace_t *ptr, ITraceObject *sweepObject, CTraceRay *ray, ITraceObject *obstacle, simplex_t &simplex )
{
	int testCount = 1, obstacleCount = 1;
	unsigned int testIndex[4], obstacleIndex[4];
	testIndex[0] = simplex.verts[0].testIndex;
	obstacleIndex[0] = simplex.verts[0].obstacleIndex;
	Assert( simplex.vertCount <= 4 );
	int i, j;
	for ( i = 1; i < simplex.vertCount; i++ )
	{
		for ( j = 0; j < obstacleCount; j++ )
		{
			if ( obstacleIndex[j] == simplex.verts[i].obstacleIndex )
				break;
		}
		if ( j == obstacleCount )
		{
			obstacleIndex[obstacleCount++] = simplex.verts[i].obstacleIndex;
		}

		for ( j = 0; j < testCount; j++ )
		{
			if ( testIndex[j] == simplex.verts[i].testIndex )
				break;
		}
		if ( j == testCount )
		{
			testIndex[testCount++] = simplex.verts[i].testIndex;
		}
	}

	if ( simplex.vertCount < 3 )
	{
		if ( simplex.vertCount == 2 && testCount == 2 )
		{
			// edge / point
			Vector t0 = sweepObject->GetVertByIndex( testIndex[0] );
			Vector t1 = sweepObject->GetVertByIndex( testIndex[1] );
			Vector edge = t1-t0;
			Vector tangent = CrossProduct( edge, ray->m_delta );
			ptr->plane.normal = CrossProduct( edge, tangent );
			VectorNormalize( ptr->plane.normal );
			ptr->plane.dist = DotProduct( t0 + ptr->endpos, ptr->plane.normal );
			return;
		}
	}
	if ( testCount == 3 )
	{
		// face / xxx
		Vector t0 = sweepObject->GetVertByIndex( testIndex[0] );
		Vector t1 = sweepObject->GetVertByIndex( testIndex[1] );
		Vector t2 = sweepObject->GetVertByIndex( testIndex[2] );
		ptr->plane.normal = CrossProduct( t1-t0, t2-t0 );
		VectorNormalize( ptr->plane.normal );
		if ( DotProduct( ptr->plane.normal, ray->m_delta ) > 0 )
		{
			ptr->plane.normal = -ptr->plane.normal;
		}
		ptr->plane.dist = DotProduct( t0 + ptr->endpos, ptr->plane.normal );
	}
	else if ( testCount == 2 && obstacleCount == 2 )
	{
		// edge / edge
		Vector t0 = sweepObject->GetVertByIndex( testIndex[0] );
		Vector t1 = sweepObject->GetVertByIndex( testIndex[1] );
		Vector t2 = obstacle->GetVertByIndex( obstacleIndex[0] );
		Vector t3 = obstacle->GetVertByIndex( obstacleIndex[1] );
		ptr->plane.normal = CrossProduct( t1-t0, t3-t2 );
		VectorNormalize( ptr->plane.normal );
		if ( DotProduct( ptr->plane.normal, ray->m_delta ) > 0 )
		{
			ptr->plane.normal = -ptr->plane.normal;
		}
		ptr->plane.dist = DotProduct( t0 + ptr->endpos, ptr->plane.normal );
	}
	else if ( obstacleCount == 3 )
	{
		// xxx / face
		Vector t0 = obstacle->GetVertByIndex( obstacleIndex[0] );
		Vector t1 = obstacle->GetVertByIndex( obstacleIndex[1] );
		Vector t2 = obstacle->GetVertByIndex( obstacleIndex[2] );
		ptr->plane.normal = CrossProduct( t1-t0, t2-t0 );
		VectorNormalize( ptr->plane.normal );
		if ( DotProduct( ptr->plane.normal, ray->m_delta ) > 0 )
		{
			ptr->plane.normal = -ptr->plane.normal;
		}
		ptr->plane.dist = DotProduct( t0, ptr->plane.normal );
	}
	else
	{
		ptr->plane.normal = -ray->m_dir;
		if ( simplex.vertCount )
		{
			ptr->plane.dist = DotProduct( ptr->plane.normal, obstacle->GetVertByIndex( simplex.verts[0].obstacleIndex ) );
		}
		else
			ptr->plane.dist = 0.f;
	}
}

// clip a direction vector to a plane (ray begins at the origin)
inline float Clip( const Vector &dir, const Vector &pos, const Vector &normal )
{
	float dist = DotProduct(pos, normal);
	float cosTheta = DotProduct(dir,normal);
	if ( cosTheta > 0 )
		return dist / cosTheta;

	// parallel or not facing the plane
	return 1e24f;
}

// This is the first iteration of solving time of intersection.
// It needs to test all 4 faces of the tetrahedron to find the one the ray leaves through
// this is done by finding the closest plane by clipping the ray to each plane
Vector simplex_t::ClipRayToTetrahedronBase( const Vector &dir )
{
	Vector AB = verts[0].position - verts[3].position;
	Vector AC = verts[1].position - verts[3].position;
	Vector AD = verts[2].position - verts[3].position;
	Vector BC = verts[1].position - verts[0].position;
	Vector BD = verts[2].position - verts[0].position;

	// compute face normals
	Vector ABC, ACD, ADB, BCD;
	CrossProduct( AB, AC, ABC );
	CrossProduct( AC, AD, ACD );
	CrossProduct( AD, AB, ADB );
	CrossProduct( BD, BC, BCD );	// flipped to point out of the tetrahedron

	// NOTE: These cancel out in the clipping equation
	//VectorNormalize(ABC);
	//VectorNormalize(ACD);
	//VectorNormalize(ADB);
	//VectorNormalize(BCD);

	// Assert valid tetrahedron/winding order
#if CHECK_TOI_CALCS
	Assert(DotProduct(verts[2].position, ABC) < DotProduct(verts[3].position, ABC ));
	Assert(DotProduct(verts[0].position, ACD) < DotProduct(verts[3].position, ACD ));
	Assert(DotProduct(verts[1].position, ADB) < DotProduct(verts[3].position, ADB ));
	Assert(DotProduct(verts[3].position, BCD) < DotProduct(verts[0].position, BCD ));
#endif

	float dists[4];
	dists[0] = Clip( dir, verts[3].position, ABC );
	dists[1] = Clip( dir, verts[3].position, ACD );
	dists[2] = Clip( dir, verts[3].position, ADB );
	dists[3] = Clip( dir, verts[0].position, BCD );
	float dmin = dists[3];
	int best = 3;
	for ( int i = 0; i < 3; i++ )
	{
		if ( dists[i] < dmin )
		{
			best = i;
			dmin = dists[i];
		}
	}

	vertCount = 3;
	// push back down to a triangle
	// Note that we need to preserve winding so that the vector order assumptions above are still valid!
	switch( best )
	{
	case 0:
		verts[2] = verts[3];
		return ABC;
	case 1:
		verts[0] = verts[3];
		return ACD;
	case 2:
		verts[1] = verts[3];
		return ADB;
	case 3:
		// swap 1 & 2
		verts[3] = verts[1];
		verts[1] = verts[2];
		verts[2] = verts[3];
		return BCD;
	}
	Assert(0); // failed!
	return vec3_origin;
}

// for subsequent iterations you don't need to test one of the faces (face you previously left through)
// so only test the three faces involving the new point A
Vector simplex_t::ClipRayToTetrahedron( const Vector &dir )
{
	Vector AB = verts[0].position - verts[3].position;
	Vector AC = verts[1].position - verts[3].position;
	Vector AD = verts[2].position - verts[3].position;

	// compute face normals
	Vector ABC, ACD, ADB;
	CrossProduct( AB, AC, ABC );
	CrossProduct( AC, AD, ACD );
	CrossProduct( AD, AB, ADB );

	// NOTE: These cancel out in the clipping equation
	//VectorNormalize(ABC);
	//VectorNormalize(ACD);
	//VectorNormalize(ADB);

	// Assert valid tetrahedron/winding order
#if CHECK_TOI_CALCS
	Assert(DotProduct(verts[2].position, ABC) < DotProduct(verts[3].position, ABC ));
	Assert(DotProduct(verts[0].position, ACD) < DotProduct(verts[3].position, ACD ));
	Assert(DotProduct(verts[1].position, ADB) < DotProduct(verts[3].position, ADB ));
#endif

	float dists[3];
	dists[0] = Clip( dir, verts[3].position, ABC );
	dists[1] = Clip( dir, verts[3].position, ACD );
	dists[2] = Clip( dir, verts[3].position, ADB );

	float dmin = dists[2];
	int best = 2;
	for ( int i = 0; i < 2; i++ )
	{
		if ( dists[i] < dmin )
		{
			best = i;
			dmin = dists[i];
		}
	}

	vertCount = 3;
	// push back down to a triangle
	// Note that we need to preserve winding so that the vector order assumptions above are still valid!
	switch( best )
	{
	case 0:
		verts[2] = verts[3];
		return ABC;
	case 1:
		verts[0] = verts[3];
		return ACD;
	case 2:
		verts[1] = verts[3];
		return ADB;
	}
	return vec3_origin;
}

float simplex_t::ClipRayToTriangle( const Vector &dir, float epsilon )
{
	Vector AB = verts[0].position - verts[2].position;
	Vector AC = verts[1].position - verts[2].position;
	Vector BC = verts[1].position - verts[0].position;

	// compute face normal
	Vector ABC;
	CrossProduct( AB, AC, ABC );  // this points toward the origin
	VectorNormalize(ABC);
	Vector edgeAB, edgeAC, edgeBC;
	// these should point out of the triangle
	CrossProduct( AB, ABC, edgeAB );
	CrossProduct( ABC, AC, edgeAC );
	CrossProduct( BC, ABC, edgeBC );

	// NOTE: These cancel out in the clipping equation
	VectorNormalize(edgeAB);
	VectorNormalize(edgeAC);
	VectorNormalize(edgeBC);

#if CHECK_TOI_CALCS
	Assert(DotProduct(verts[2].position, ABC) < 0); // points toward
	// Assert valid triangle/winding order (all normals point away from the origin)
	Assert(DotProduct(verts[2].position, edgeAB) > 0);
	Assert(DotProduct(verts[2].position, edgeAC) > 0);
	Assert(DotProduct(verts[0].position, edgeBC) > 0);
#endif

	float dists[3];
	dists[0] = Clip( dir, verts[0].position, edgeAB );
	dists[1] = Clip( dir, verts[1].position, edgeAC );
	dists[2] = Clip( dir, verts[1].position, edgeBC );
	Vector *normals[3] = {&edgeAB, &edgeAC, &edgeBC};

	float dmin = dists[0];
	int best = 0;
	if ( dists[1] < dmin )
	{
		dmin = dists[1];
		best = 1;
	}
	if ( dists[2] < dmin )
	{
		best = 2;
		dmin = dists[2];
	}
	float dot = DotProduct( dir, *normals[best] );
	if ( dot <= 0 )
		return 1e24f;
	dmin += epsilon/dot;

	return dmin;
}

// Solve for time of intersection along the sweep
// Do this by iteratively clipping the ray to the tetrahedron containing the origin
// when a triangle is found intersecting the ray, reduce the simplex to that triangle
// and then re-expand it to a tetrahedron using the support point normal to the triangle (away from the origin)
// iterate until no new points can be found.  That's the surface of the sum.
float CTraceSolver::SolveMeshIntersection( simplex_t &simplex )
{
	Vector tmp;
	Assert( simplex.vertCount == 4 );
	if ( simplex.vertCount < 4 )
		return 0.0f;

	Vector v = simplex.ClipRayToTetrahedronBase( m_ray->m_dir );

	simplexvert_t vert;
	// safe loop, max 100 iterations
	for ( int i = 0; i < 100; i++ )
	{
		VectorNormalize(v);
		vert.testIndex = m_sweepObject->SupportMap( v, &vert.position );
		vert.sweepIndex = m_ray->SupportMap( v, &tmp );
		VectorAdd( vert.position, tmp, vert.position );
		vert.obstacleIndex = m_obstacle->SupportMap( -v, &tmp );
		VectorSubtract( vert.position, tmp, vert.position );

		// map the new separating axis (NOTE: This test is inverted from the GJK - we are trying to get out, not in)
		// found a separating axis, we've moved the sweep back enough
		float dist = DotProduct( v, simplex.verts[0].position ) + TEST_EPSILON;
		if ( DotProduct( v, vert.position ) <= dist )
		{
			Vector BC = simplex.verts[1].position - simplex.verts[0].position;
			Vector BD = simplex.verts[2].position - simplex.verts[0].position;

			// compute face normals
			Vector BCD;
			CrossProduct( BC, BD, BCD );
			// NOTE: This cancels out inside Clip()
			//VectorNormalize( BCD );
			// clip ray to triangle
			return Clip( m_ray->m_dir, simplex.verts[0].position, BCD );
		}

		// add the new vert
		simplex.verts[simplex.vertCount] = vert;
		simplex.vertCount++;
		v = simplex.ClipRayToTetrahedron( m_ray->m_dir );
	}

	Assert(0);
	return 0.0f;
}

// similar to SolveMeshIntersection, but solves projected into the 2D triangle simplex remaining
// this is used for the near miss case
float CTraceSolver::SolveMeshIntersection2D( simplex_t &simplex )
{
	AssertMsg( simplex.vertCount == 3, "simplex.vertCount != 3: %d", simplex.vertCount );
	if ( simplex.vertCount != 3 )
		return 0.0f;

	// note: This should really do this iteratively in case the triangle is coplanar with another triangle that 
	// is between this one and the edge of the sum in this plane
	float dist = simplex.ClipRayToTriangle( m_ray->m_dir, m_epsilon );
	return dist;
}


static const Vector g_xpos(1,0,0), g_xneg(-1,0,0);
static const Vector g_ypos(0,1,0), g_yneg(0,-1,0);
static const Vector g_zpos(0,0,1), g_zneg(0,0,-1);

void TraceGetAABB_r( Vector *pMins, Vector *pMaxs, const IVP_Compact_Ledgetree_Node *node, CTraceIVP &ivp )
{
	if ( node->is_terminal() == IVP_TRUE )
	{
		Vector tmp;
		ivp.SetLedge( node->get_compact_ledge() );
		ivp.SupportMap( g_xneg, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		ivp.SupportMap( g_yneg, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		ivp.SupportMap( g_zneg, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		ivp.SupportMap( g_xpos, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		ivp.SupportMap( g_ypos, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		ivp.SupportMap( g_zpos, &tmp );
		AddPointToBounds( tmp, *pMins, *pMaxs );
		return;
	}

	TraceGetAABB_r( pMins, pMaxs, node->left_son(), ivp );
	TraceGetAABB_r( pMins, pMaxs, node->right_son(), ivp );
}

void CPhysicsTrace::GetAABB( Vector *pMins, Vector *pMaxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles )
{
	CTraceIVP ivp( pCollide, collideOrigin, collideAngles );

	if ( ivp.SetSingleConvex() )
	{
		Vector tmp;
		ivp.SupportMap( g_xneg, &tmp );
		pMins->x = tmp.x;
		ivp.SupportMap( g_yneg, &tmp );
		pMins->y = tmp.y;
		ivp.SupportMap( g_zneg, &tmp );
		pMins->z = tmp.z;

		ivp.SupportMap( g_xpos, &tmp );
		pMaxs->x = tmp.x;
		ivp.SupportMap( g_ypos, &tmp );
		pMaxs->y = tmp.y;
		ivp.SupportMap( g_zpos, &tmp );
		pMaxs->z = tmp.z;
	}
	else
	{
		const IVP_Compact_Ledgetree_Node *lt_node_root;
		lt_node_root = pCollide->GetCompactSurface()->get_compact_ledge_tree_root();
		ClearBounds( *pMins, *pMaxs );
		TraceGetAABB_r( pMins, pMaxs, lt_node_root, ivp );
	}
	// JAY: Disable this here, do it in the engine instead.  That way the tools get
	// accurate bboxes
#if 0
	const float radius = g_PhysicsUnits.collisionSweepEpsilon;
	mins -= Vector(radius,radius,radius);
	maxs += Vector(radius,radius,radius);
#endif
}

void TraceGetExtent_r( const IVP_Compact_Ledgetree_Node *node, CTraceIVP &ivp, const Vector &dir, float &dot, Vector &point )
{
	if ( node->is_terminal() == IVP_TRUE )
	{
		ivp.SetLedge( node->get_compact_ledge() );
		Vector tmp;
		ivp.SupportMap( dir, &tmp );
		float newDot = DotProduct( tmp, dir );

		if ( newDot > dot )
		{
			dot = newDot;
			point = tmp;
		}
		return;
	}

	TraceGetExtent_r( node->left_son(), ivp, dir, dot, point );
	TraceGetExtent_r( node->right_son(), ivp, dir, dot, point );
}


Vector CPhysicsTrace::GetExtent( const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, const Vector &direction )
{
	CTraceIVP ivp( pCollide, collideOrigin, collideAngles );

	if ( ivp.SetSingleConvex() )
	{
		Vector tmp;
		ivp.SupportMap( direction, &tmp );
		return tmp;
	}
	else
	{
		const IVP_Compact_Ledgetree_Node *lt_node_root;
		lt_node_root = pCollide->GetCompactSurface()->get_compact_ledge_tree_root();
		Vector out = vec3_origin;
		float tmp = -1e6f;
		TraceGetExtent_r( lt_node_root, ivp, direction, tmp, out );
		return out;
	}
}

bool CPhysicsTrace::IsBoxIntersectingCone( const Vector &boxAbsMins, const Vector &boxAbsMaxs, const truncatedcone_t &cone )
{
	trace_t tr;
	CM_ClearTrace( &tr );
	bool bPoint = (boxAbsMins == boxAbsMaxs) ? true : false;
	CTraceAABB box( boxAbsMins - cone.origin, boxAbsMaxs - cone.origin, bPoint );
	CTraceCone traceCone( cone, -cone.origin );

	// offset the space of this sweep so that the surface is at the origin of the solution space
	CTraceRay ray( vec3_origin, vec3_origin );

	CTraceSolver solver( &tr, &box, &ray, &traceCone, boxAbsMaxs );
	solver.DoSweep();

	return tr.startsolid;
}



CPhysicsTrace::CPhysicsTrace()
{
}

CPhysicsTrace::~CPhysicsTrace()
{
}

CVisitHash::CVisitHash()
{
	m_vertVisitID = 1;
	memset( m_vertVisit, 0, sizeof(m_vertVisit) );
}