//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"

#include "ivp_surbuild_pointsoup.hxx"
#include "ivp_surbuild_ledge_soup.hxx"
#include "ivp_surman_polygon.hxx"
#include "ivp_compact_surface.hxx"
#include "ivp_compact_ledge.hxx"
#include "ivp_compact_ledge_solver.hxx"
#include "ivp_halfspacesoup.hxx"
#include "ivp_surbuild_halfspacesoup.hxx"
#include "ivp_template_surbuild.hxx"
#include "hk_mopp/ivp_surbuild_mopp.hxx"
#include "hk_mopp/ivp_surman_mopp.hxx"
#include "hk_mopp/ivp_compact_mopp.hxx"
#include "ivp_surbuild_polygon_convex.hxx"
#include "ivp_templates_intern.hxx"

#include "cmodel.h"
#include "physics_trace.h"
#include "vcollide_parse_private.h"
#include "physics_virtualmesh.h"

#include "mathlib/polyhedron.h"
#include "tier1/byteswap.h"
#include "physics_globals.h"
#include "tier1/smartptr.h"

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

class CPhysCollideCompactSurface;
struct bboxcache_t
{
	Vector			mins;
	Vector			maxs;
	CPhysCollideCompactSurface	*pCollide;
};

class CPhysicsCollision : public IPhysicsCollision
{
public:
	CPhysicsCollision()
	{
	}
	CPhysConvex	*ConvexFromVerts( Vector **pVerts, int vertCount );
	CPhysConvex	*ConvexFromVertsFast( Vector **pVerts, int vertCount );
	CPhysConvex	*ConvexFromPlanes( float *pPlanes, int planeCount, float mergeDistance );
	CPhysConvex *ConvexFromConvexPolyhedron( const CPolyhedron &ConvexPolyhedron );
	void ConvexesFromConvexPolygon( const Vector &vPolyNormal, const Vector *pPoints, int iPointCount, CPhysConvex **pOutput );
	CPhysConvex	*RebuildConvexFromPlanes( CPhysConvex *pConvex, float mergeDistance );
	float ConvexVolume( CPhysConvex *pConvex );
	float ConvexSurfaceArea( CPhysConvex *pConvex );
	CPhysCollide *ConvertConvexToCollide( CPhysConvex **pConvex, int convexCount );
	CPhysCollide *ConvertConvexToCollideParams( CPhysConvex **pConvex, int convexCount, const convertconvexparams_t &convertParams );

	
	CPolyhedron *PolyhedronFromConvex( CPhysConvex * const pConvex, bool bUseTempPolyhedron );
	int GetConvexesUsedInCollideable( const CPhysCollide *pCollideable, CPhysConvex **pOutputArray, int iOutputArrayLimit );

	// store game-specific data in a convex solid
	void SetConvexGameData( CPhysConvex *pConvex, unsigned int gameData );
	void ConvexFree( CPhysConvex *pConvex );
	
	CPhysPolysoup *PolysoupCreate( void );
	void PolysoupDestroy( CPhysPolysoup *pSoup );
	void PolysoupAddTriangle( CPhysPolysoup *pSoup, const Vector &a, const Vector &b, const Vector &c, int materialIndex7bits );
	CPhysCollide *ConvertPolysoupToCollide( CPhysPolysoup *pSoup, bool useMOPP = true );

	int	CollideSize( CPhysCollide *pCollide );
	int	CollideWrite( char *pDest, CPhysCollide *pCollide, bool bSwap = false );
	// Get the AABB of an oriented collide
	virtual void CollideGetAABB( Vector *pMins, Vector *pMaxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles );
	virtual Vector CollideGetExtent( const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, const Vector &direction );
	// compute the volume of a collide
	virtual float			CollideVolume( CPhysCollide *pCollide );
	virtual float			CollideSurfaceArea( CPhysCollide *pCollide );

	// Free a collide that was created with ConvertConvexToCollide()
	// UNDONE: Move this up near the other Collide routines when the version is changed
	virtual void			DestroyCollide( CPhysCollide *pCollide );

	CPhysCollide *BBoxToCollide( const Vector &mins, const Vector &maxs );
	CPhysConvex	*BBoxToConvex( const Vector &mins, const Vector &maxs );

	// loads a set of solids into a vcollide_t
	virtual void			VCollideLoad( vcollide_t *pOutput, int solidCount, const char *pBuffer, int size, bool swap );
	// destroyts the set of solids created by VCollideLoad
	virtual void			VCollideUnload( vcollide_t *pVCollide );

	// Trace an AABB against a collide
	void TraceBox( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr );
	void TraceBox( const Ray_t &ray, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr );
	void TraceBox( const Ray_t &ray, unsigned int contentsMask, IConvexInfo *pConvexInfo, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr );
	// Trace one collide against another
	void TraceCollide( const Vector &start, const Vector &end, const CPhysCollide *pSweepCollide, const QAngle &sweepAngles, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr );
	bool IsBoxIntersectingCone( const Vector &boxAbsMins, const Vector &boxAbsMaxs, const truncatedcone_t &cone );

	// begins parsing a vcollide.  NOTE: This keeps pointers to the text
	// If you delete the text and call members of IVPhysicsKeyParser, it will crash
	virtual IVPhysicsKeyParser	*VPhysicsKeyParserCreate( const char *pKeyData );
	// Free the parser created by VPhysicsKeyParserCreate
	virtual void			VPhysicsKeyParserDestroy( IVPhysicsKeyParser *pParser );

	// creates a list of verts from a collision mesh
	int	CreateDebugMesh( const CPhysCollide *pCollisionModel, Vector **outVerts );
	// destroy the list of verts created by CreateDebugMesh
	void DestroyDebugMesh( int vertCount, Vector *outVerts );
	// create a queryable version of the collision model
	ICollisionQuery *CreateQueryModel( CPhysCollide *pCollide );
	// destroy the queryable version
	void DestroyQueryModel( ICollisionQuery *pQuery );

	virtual IPhysicsCollision *ThreadContextCreate( void );
	virtual void			ThreadContextDestroy( IPhysicsCollision *pThreadContex );
	virtual unsigned int	ReadStat( int statID ) { return 0; }
	virtual void			CollideGetMassCenter( CPhysCollide *pCollide, Vector *pOutMassCenter );
	virtual void			CollideSetMassCenter( CPhysCollide *pCollide, const Vector &massCenter );

	virtual int				CollideIndex( const CPhysCollide *pCollide );
	virtual Vector			CollideGetOrthographicAreas( const CPhysCollide *pCollide );
	virtual void			OutputDebugInfo( const CPhysCollide *pCollide );
	virtual CPhysCollide	*CreateVirtualMesh(const virtualmeshparams_t &params) { return ::CreateVirtualMesh(params); }
	virtual bool			GetBBoxCacheSize( int *pCachedSize, int *pCachedCount );

	virtual bool			SupportsVirtualMesh() { return true; }

	virtual CPhysCollide	*UnserializeCollide( char *pBuffer, int size, int index );
	virtual void			CollideSetOrthographicAreas( CPhysCollide *pCollide, const Vector &areas );

private:
	void InitBBoxCache();
	bool IsBBoxCache( CPhysCollide *pCollide );
	void AddBBoxCache( CPhysCollideCompactSurface *pCollide, const Vector &mins, const Vector &maxs );
	CPhysCollideCompactSurface *GetBBoxCache( const Vector &mins, const Vector &maxs );
	CPhysCollideCompactSurface *FastBboxCollide( const CPhysCollideCompactSurface *pCollide, const Vector &mins, const Vector &maxs );

private:
	CPhysicsTrace		m_traceapi;
	CUtlVector<bboxcache_t>	m_bboxCache;
	byte				m_bboxVertMap[8];
};

CPhysicsCollision g_PhysicsCollision;
IPhysicsCollision *physcollision = &g_PhysicsCollision;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CPhysicsCollision, IPhysicsCollision, VPHYSICS_COLLISION_INTERFACE_VERSION, g_PhysicsCollision );


//-----------------------------------------------------------------------------
// Abstract compact_surface vs. compact_mopp
//-----------------------------------------------------------------------------
#define IVP_COMPACT_SURFACE_ID			MAKEID('I','V','P','S')
#define IVP_COMPACT_SURFACE_ID_SWAPPED	MAKEID('S','P','V','I')
#define IVP_COMPACT_MOPP_ID				MAKEID('M','O','P','P')
#define VPHYSICS_COLLISION_ID			MAKEID('V','P','H','Y')
#define VPHYSICS_COLLISION_VERSION		0x0100
// You can disable all of the havok Mopp collision model building by undefining this symbol
#define ENABLE_IVP_MOPP	0

struct ivpcompactledge_t {
        DECLARE_BYTESWAP_DATADESC()

        int             c_point_offset; // byte offset from 'this' to (ledge) point array
        union {
                int     ledgetree_node_offset;
                int     client_data;    // if indicates a non terminal ledge
        };

        union {
                int bf1;

                struct {
                        uint    has_chilren_flag:2;
                        int             is_compact_flag:2;  // if false than compact ledge uses points outside this piece of memory
                        uint    dummy:4;
                        uint    size_div_16:24; 
                };
        };

        short   n_triangles;
        short   for_future_use;
};

// 48 bytes
// Just like a btCompoundShape.
struct ivpcompactsurface_t {
        DECLARE_BYTESWAP_DATADESC()

        float   mass_center[3];
        float   rotation_inertia[3];
        float   upper_limit_radius;

        union {
                int bf1; // HACK: Allow datamap to take address of this bitfield

                struct {
                        int             max_deviation : 8;
                        int             byte_size : 24;
                };
        };

        int             offset_ledgetree_root;
        int             dummy[3];                       // dummy[2] is "IVPS" or 0
};

struct ivpcompactedge_t {
        DECLARE_BYTESWAP_DATADESC()

        union {
                int bf1;

                struct {
                        uint    start_point_index:16;           // point index
                        int             opposite_index:15;                      // rel to this // maybe extra array, 3 bits more tha>
                        uint    is_virtual:1;
                };
        };
};

struct ivpcompactledgenode_t {
        DECLARE_BYTESWAP_DATADESC()

        int             offset_right_node; // (if != 0 than children
        int             offset_compact_ledge; // (if != 0, pointer to hull that contains all subelements
        float   center[3];      // in object_coords
        float   radius; // size of sphere
        unsigned char box_sizes[3];
        unsigned char free_0;

        // Functions

        const ivpcompactledge_t *GetCompactLedge() const {
                Assert(this->offset_right_node == 0);
                return (ivpcompactledge_t *)((char *)this + this->offset_compact_ledge);
        }

        const ivpcompactledgenode_t *GetLeftSon() const {
                Assert(this->offset_right_node);
                return this + 1;
        }

        const ivpcompactledgenode_t *GetRightSon() const {
                Assert(this->offset_right_node);
                return (ivpcompactledgenode_t *)((char *)this + this->offset_right_node);
        }

        bool IsTerminal() const {
                return (this->offset_right_node == 0);
        }

        const ivpcompactledge_t *GetCompactHull() const {
                if (this->offset_compact_ledge)
                        return (ivpcompactledge_t *)((char *)this + this->offset_compact_ledge);
                else
                        return NULL;
        }
};


struct physcollideheader_t
{
	DECLARE_BYTESWAP_DATADESC();
	int	size;
	int		vphysicsID;
	short	version;
	short	modelType;

	void Defaults( short inputModelType )
	{
		vphysicsID = VPHYSICS_COLLISION_ID;
		
		version = VPHYSICS_COLLISION_VERSION;
		modelType = inputModelType;
	}
};

struct compactsurfaceheader_t : public physcollideheader_t
{
	DECLARE_BYTESWAP_DATADESC();
	int		surfaceSize;
	Vector	dragAxisAreas;
	int		axisMapSize;

	void CompactSurface( const IVP_Compact_Surface *pSurface, const Vector &orthoAreas )
	{
		Defaults( COLLIDE_POLY );
		surfaceSize = pSurface->byte_size;
		dragAxisAreas = orthoAreas;
		axisMapSize = 0;	// NOTE: not yet supported
	}
};

BEGIN_BYTESWAP_DATADESC( physcollideheader_t )
	DEFINE_FIELD( vphysicsID, FIELD_INTEGER ),
	DEFINE_FIELD( version, FIELD_SHORT),
	DEFINE_FIELD( modelType, FIELD_SHORT ),
END_BYTESWAP_DATADESC()

BEGIN_BYTESWAP_DATADESC_( compactsurfaceheader_t, physcollideheader_t )
	DEFINE_FIELD( surfaceSize, FIELD_INTEGER ),
	DEFINE_FIELD( dragAxisAreas, FIELD_VECTOR ),
	DEFINE_FIELD( axisMapSize, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()

#if ENABLE_IVP_MOPP
struct moppheader_t : public physcollideheader_t
{
	int moppSize;
	void Mopp( const IVP_Compact_Mopp *pMopp )
	{
		Defaults( COLLIDE_MOPP );
		moppSize = pMopp->byte_size;
	}
};
#endif

class CPhysCollidePx : public CPhysCollide
{
public:
	CPhysCollidePx(PxShape *shape)
	{
		m_pPxShape = shape;
	}

	virtual PxShape *GetPxShape()
	{
		return m_pPxShape;
	}

	IVP_SurfaceManager *CreateSurfaceManager( short & ) const { return NULL; }
	virtual void GetAllLedges( IVP_U_BigVector<IVP_Compact_Ledge> &ledges ) const {}
	unsigned int GetSerializationSize() { return 0; }
	int GetVCollideIndex() const { return 0; }
	Vector GetMassCenter() const { return Vector(0, 0, 0); }
	void SetMassCenter( const Vector &massCenter ) {}
	void OutputDebugInfo() const {}
	unsigned int GetSerializationSize() const { return 0; }
	unsigned int SerializeToBuffer( char *pDest, bool bSwap = false ) const { return 0; }
private:
	PxShape *m_pPxShape;
};

class CPhysCollideCompactSurface : public CPhysCollide
{
public:
	~CPhysCollideCompactSurface();
	CPhysCollideCompactSurface( const char *pBuffer, unsigned int size, int index, bool swap = false );
	CPhysCollideCompactSurface( const compactsurfaceheader_t *pHeader, int index, bool swap = false );
	CPhysCollideCompactSurface( IVP_Compact_Surface *pSurface );
	
	void Init( const char *pBuffer, unsigned int size, int index, bool swap = false );

	// IPhysCollide
	virtual int GetVCollideIndex() const { return m_pCompactSurface->dummy[0]; }
	virtual IVP_SurfaceManager *CreateSurfaceManager( short & ) const;
	virtual void GetAllLedges( IVP_U_BigVector<IVP_Compact_Ledge> &ledges ) const;
	virtual unsigned int GetSerializationSize() const;
	virtual Vector GetMassCenter() const;
	virtual void SetMassCenter( const Vector &massCenter );
	virtual unsigned int SerializeToBuffer( char *pDest, bool bSwap = false ) const;
	virtual Vector GetOrthographicAreas() const;
	void SetOrthographicAreas( const Vector &areas );
	virtual void ComputeOrthographicAreas( float epsilon );
	virtual void OutputDebugInfo() const;

	const IVP_Compact_Surface		*GetCompactSurface() const { return m_pCompactSurface; }
	virtual const collidemap_t *GetCollideMap() const { return m_pCollideMap; }

private:

	struct hullinfo_t
	{
		hullinfo_t()
		{
			hasOuterHull = false;
			convexCount = 0;
		}
		bool	hasOuterHull;
		int		convexCount;
	};

	void ComputeHullInfo_r( hullinfo_t *pOut, const IVP_Compact_Ledgetree_Node *node ) const;
	void InitCollideMap();

	IVP_Compact_Surface		*m_pCompactSurface;
	Vector					m_orthoAreas;
	collidemap_t			*m_pCollideMap;
};


static const IVP_Compact_Surface *ConvertPhysCollideToCompactSurface( const CPhysCollide *pCollide )
{
	return pCollide->GetCompactSurface();
}

IVP_SurfaceManager *CreateSurfaceManager( const CPhysCollide *pCollisionModel, short &collideType )
{
	return pCollisionModel ? pCollisionModel->CreateSurfaceManager( collideType ) : NULL;
}

void OutputCollideDebugInfo( const CPhysCollide *pCollisionModel )
{
	pCollisionModel->OutputDebugInfo();
}

namespace ivp_compat
{
	struct collideheader_t
	{
		int		vphysicsID;
		short	version;
		short	modelType;
	};

	struct compactsurfaceheader_t
	{
		int		surfaceSize;
		Vector	dragAxisAreas;
		int		axisMapSize;
	};

	struct moppsurfaceheader_t
	{
		int moppSize;
	};

	struct compactsurface_t
	{
		float	mass_center[3];
		float	rotation_inertia[3];
		float	upper_limit_radius;

		unsigned int	max_factor_surface_deviation	: 8;
		int		        byte_size						: 24;
		int		        offset_ledgetree_root;
		int		        dummy[3];
	};

	struct compactmopp_t
	{
		float	mass_center[3];
		float	rotation_inertia[3];
		float	upper_limit_radius;

		unsigned int max_factor_surface_deviation	: 8;
		int          byte_size						: 24;
		int	         offset_ledgetree_root;
		int          offset_ledges;
		int          size_convex_hull;
		int	         dummy;
	};

	struct compactledge_t
	{
		int		c_point_offset;

		union
		{
			int	ledgetree_node_offset;
			int	client_data;
		};

		struct
		{
			uint	has_children_flag	: 2;
			int		is_compact_flag		: 2;
			uint	dummy				: 4;
			uint	size_div_16			: 24; 
		};

		short	n_triangles;
		short	for_future_use;
	};

	struct compactedge_t
	{
		uint    start_point_index	: 16;
		int		opposite_index		: 15;
		uint	is_virtual			: 1;
	};

	struct compacttriangle_t
	{
		uint	tri_index		: 12;
		uint	pierce_index	: 12;
		uint	material_index	: 7;
		uint	is_virtual		: 1;
		compactedge_t c_three_edges[3];
	};

	struct compactledgenode_t
	{
		int		offset_right_node;
		int		offset_compact_ledge;
		float	center[3];
		float	radius;
		unsigned char box_sizes[3];
		unsigned char free_0;

		const compactledge_t *GetCompactLedge() const
		{
			//VJoltAssert( this->offset_right_node == 0 );
			return ( compactledge_t * )( ( char * )this + this->offset_compact_ledge );
		}

		const compactledgenode_t *GetLeftChild() const
		{
			//VJoltAssert( this->offset_right_node );
			return this + 1;
		}

		const compactledgenode_t *GetRightChild() const
		{
			//VJoltAssert( this->offset_right_node );
			return ( compactledgenode_t * )( ( char * )this + this->offset_right_node );
		}

		bool IsTerminal() const
		{
			return this->offset_right_node == 0;
		}

		const compactledge_t *GetCompactHull() const
		{
			if ( this->offset_compact_ledge )
				return ( compactledge_t * )( ( char * )this + this->offset_compact_ledge );
			else
				return nullptr;
		}
	};
}

CPhysCollide *CPhysCollide::UnserializeFromBuffer( const char *pBuffer, unsigned int size, int index, bool swap )
{
	const ivp_compat::collideheader_t *pHeader = reinterpret_cast<const ivp_compat::collideheader_t *>(pBuffer);
	if ( pHeader->vphysicsID == VPHYSICS_COLLISION_ID )
	{
		Assert(pHeader->version == VPHYSICS_COLLISION_VERSION);
		switch( pHeader->modelType )
		{
		case COLLIDE_POLY:
			return new CPhysCollideCompactSurface( (compactsurfaceheader_t *)pHeader, index, swap );
		case COLLIDE_MOPP:
#if ENABLE_IVP_MOPP
			return new CPhysCollideMopp( (moppheader_t *)pHeader );
#else
			DevMsg( 2, "Null physics model\n");
			return NULL;
#endif
		default:
			Assert(0);
			return NULL;
		}
	}
	const IVP_Compact_Surface *pSurface = reinterpret_cast<const IVP_Compact_Surface *>(pBuffer);
	if ( pSurface->dummy[2] == IVP_COMPACT_MOPP_ID )
	{
#if ENABLE_IVP_MOPP
		return new CPhysCollideMopp( pBuffer, size );
#else
		Assert(0);
		return NULL;
#endif
	}
	if ( pSurface->dummy[2] == IVP_COMPACT_SURFACE_ID || 
		 pSurface->dummy[2] == IVP_COMPACT_SURFACE_ID_SWAPPED || 
		 pSurface->dummy[2] == 0 )
	{
		if ( pSurface->dummy[2] == 0 )
		{
			// UNDONE: Print a name here?
			DevMsg( 1, "Old format .PHY file loaded!!!\n" );
		}
		return new CPhysCollideCompactSurface( pBuffer, size, index, swap );
	}

	Assert(0);
	return NULL;
}

#if ENABLE_IVP_MOPP

void CPhysCollideMopp::Init( const char *pBuffer, unsigned int size )
{
	m_pMopp = (IVP_Compact_Mopp *)ivp_malloc_aligned( size, 32 );
	memcpy( m_pMopp, pBuffer, size );
}

CPhysCollideMopp::CPhysCollideMopp( const char *pBuffer, unsigned int size )
{
	Init( pBuffer, size );
}

CPhysCollideMopp::CPhysCollideMopp( const moppheader_t *pHeader )
{
	Init( (const char *)(pHeader+1), pHeader->moppSize );
}

CPhysCollideMopp::CPhysCollideMopp( IVP_Compact_Mopp *pMopp )
{
	m_pMopp = pMopp;
	pMopp->dummy = IVP_COMPACT_MOPP_ID;
}

CPhysCollideMopp::~CPhysCollideMopp()
{
	ivp_free_aligned(m_pMopp);
}

void CPhysCollideMopp::GetAllLedges( IVP_U_BigVector<IVP_Compact_Ledge> &ledges ) const
{
	IVP_Compact_Ledge_Solver::get_all_ledges( m_pMopp, &ledges );
}

IVP_SurfaceManager *CPhysCollideMopp::CreateSurfaceManager( short &collideType ) const
{
	collideType = COLLIDE_MOPP;
	return new IVP_SurfaceManager_Mopp( m_pMopp );
}

unsigned int CPhysCollideMopp::GetSerializationSize() const
{
	return m_pMopp->byte_size + sizeof(moppheader_t);
}

unsigned int CPhysCollideMopp::SerializeToBuffer( char *pDest, bool bSwap ) const
{
	moppheader_t header;
	header.Mopp( m_pMopp );
	memcpy( pDest, &header, sizeof(header) );
	pDest += sizeof(header);
	memcpy( pDest, m_pMopp, m_pMopp->byte_size );
	return GetSerializationSize();
}

Vector CPhysCollideMopp::GetMassCenter() const
{
	Vector massCenterHL;
	ConvertPositionToHL( m_pMopp->mass_center, massCenterHL );
	return massCenterHL;
}

void CPhysCollideMopp::SetMassCenter( const Vector &massCenterHL )
{
	ConvertPositionToIVP( massCenterHL, m_pMopp->mass_center );
}

void CPhysCollideMopp::OutputDebugInfo() const
{
	Msg("CollisionModel: MOPP\n");
}
#endif

void CPhysCollideCompactSurface::InitCollideMap()
{
	m_pCollideMap = NULL;
	if ( m_pCompactSurface )
	{
		IVP_U_BigVector<IVP_Compact_Ledge> ledges;
		GetAllLedges( ledges );
		// don't make these for really large models because there's a linear search involved in using this atm.
		if ( !ledges.len() || ledges.len() > 32 )
			return;
		int allocSize = sizeof(collidemap_t) + ((ledges.len()-1) * sizeof(leafmap_t));
		m_pCollideMap = (collidemap_t *)malloc(allocSize);
		m_pCollideMap->leafCount = ledges.len();
		for ( int i = 0; i < ledges.len(); i++ )
		{
			InitLeafmap( ledges.element_at(i), &m_pCollideMap->leafmap[i] );
		}
	}
}

void CPhysCollideCompactSurface::Init( const char *pBuffer, unsigned int size, int index, bool bSwap )
{
	m_pCompactSurface = (IVP_Compact_Surface *)ivp_malloc_aligned( size, 32 );
	memcpy( m_pCompactSurface, pBuffer, size );
	if ( bSwap )
	{
		m_pCompactSurface->byte_swap_all();
	}
	m_pCompactSurface->dummy[0] = index;
	m_orthoAreas.Init(1,1,1);
	InitCollideMap();
}

CPhysCollideCompactSurface::CPhysCollideCompactSurface( const char *pBuffer, unsigned int size, int index, bool swap )
{
	Init( pBuffer, size, index, swap );
}
CPhysCollideCompactSurface::CPhysCollideCompactSurface( const compactsurfaceheader_t *pHeader, int index, bool swap )
{
	Init( (const char *)(pHeader+1), pHeader->surfaceSize, index, swap );
	m_orthoAreas = pHeader->dragAxisAreas;
}

CPhysCollideCompactSurface::CPhysCollideCompactSurface( IVP_Compact_Surface *pSurface )
{
	m_pCompactSurface = pSurface;
	pSurface->dummy[2] = IVP_COMPACT_SURFACE_ID;
	m_pCompactSurface->dummy[0] = 0;
	m_orthoAreas.Init(1,1,1);
	InitCollideMap();
}

CPhysCollideCompactSurface::~CPhysCollideCompactSurface()
{
	ivp_free_aligned(m_pCompactSurface);
	if ( m_pCollideMap )
	{
		free(m_pCollideMap);
	}
}

IVP_SurfaceManager *CPhysCollideCompactSurface::CreateSurfaceManager( short &collideType ) const
{
	collideType = COLLIDE_POLY;
	return new IVP_SurfaceManager_Polygon( m_pCompactSurface );
}

void CPhysCollideCompactSurface::GetAllLedges( IVP_U_BigVector<IVP_Compact_Ledge> &ledges ) const
{
	IVP_Compact_Ledge_Solver::get_all_ledges( m_pCompactSurface, &ledges );
}

unsigned int CPhysCollideCompactSurface::GetSerializationSize() const
{
	return m_pCompactSurface->byte_size + sizeof(compactsurfaceheader_t);
}

unsigned int CPhysCollideCompactSurface::SerializeToBuffer( char *pDest, bool bSwap ) const
{
	compactsurfaceheader_t header;
	header.CompactSurface( m_pCompactSurface, m_orthoAreas );
	if ( bSwap )
	{
		CByteswap swap;
		swap.ActivateByteSwapping( true );
		swap.SwapFieldsToTargetEndian( &header );
	}
	memcpy( pDest, &header, sizeof(header) );
	pDest += sizeof(header);
	int surfaceSize = m_pCompactSurface->byte_size;
	int serializationSize = GetSerializationSize();
	if ( bSwap )
	{
		m_pCompactSurface->byte_swap_all();
	}
	memcpy( pDest, m_pCompactSurface, surfaceSize );
	return serializationSize;
}

Vector CPhysCollideCompactSurface::GetMassCenter() const
{
	Vector massCenterHL;
	ConvertPositionToHL( m_pCompactSurface->mass_center, massCenterHL );
	return massCenterHL;
}

void CPhysCollideCompactSurface::SetMassCenter( const Vector &massCenterHL )
{
	ConvertPositionToIVP( massCenterHL, m_pCompactSurface->mass_center );
}

Vector CPhysCollideCompactSurface::GetOrthographicAreas() const
{
	return m_orthoAreas;
}

void CPhysCollideCompactSurface::SetOrthographicAreas( const Vector &areas )
{
	m_orthoAreas = areas;
}


void CPhysCollideCompactSurface::ComputeOrthographicAreas( float epsilon )
{
	Vector mins, maxs, areas;

	physcollision->CollideGetAABB( &mins, &maxs, this, vec3_origin, vec3_angle );
	float side = sqrt( epsilon );
	if ( side < 1e-4f )
		side = 1e-4f;
	Vector size = maxs-mins;

	m_orthoAreas.Init(1,1,1);
	trace_t tr;
	for ( int axis = 0; axis < 3; axis++ )
	{
		int u = (axis+1)%3;
		int v = (axis+2)%3;
		int hits = 0;
		int total = 0;
		float halfSide = side * 0.5;
		for ( float u0 = mins[u] + halfSide; u0 < maxs[u]; u0 += side )
		{
			for ( float v0 = mins[v] + halfSide; v0 < maxs[v]; v0 += side )
			{
				Vector start, end;
				start[axis] = mins[axis]-1;
				end[axis] = maxs[axis]+1;
				start[u] = u0;
				end[u] = u0;
				start[v] = v0;
				end[v] = v0;

				physcollision->TraceBox( start, end, vec3_origin, vec3_origin, this, vec3_origin, vec3_angle, &tr );
				if ( tr.DidHit() )
				{
					hits++;
				}
				total++;
			}
		}
	
		if ( total <= 0 )
			total = 1;
		m_orthoAreas[axis] = (float)hits / (float)total;
	}
}


void CPhysCollideCompactSurface::ComputeHullInfo_r( hullinfo_t *pOut, const IVP_Compact_Ledgetree_Node *node ) const
{
	if ( !node->is_terminal() )
	{
		if ( node->get_compact_hull() )
			pOut->hasOuterHull = true;

		ComputeHullInfo_r( pOut, node->left_son() );
		ComputeHullInfo_r( pOut, node->right_son() );
	}
	else
	{
		// terminal node, add one ledge
		pOut->convexCount++;
	}
}


void CPhysCollideCompactSurface::OutputDebugInfo() const
{
	hullinfo_t info;

	ComputeHullInfo_r( &info, m_pCompactSurface->get_compact_ledge_tree_root() );
	const char *pOuterHull = info.hasOuterHull ? "with" : "no";
	Msg("CollisionModel: Compact Surface: %d convex pieces %s outer hull\n", info.convexCount, pOuterHull );
}

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


//-----------------------------------------------------------------------------
// Purpose: Create a convex element from a point cloud
// Input  : **pVerts - array of points
//			vertCount - length of array
// Output : opaque pointer to convex element
//-----------------------------------------------------------------------------
CPhysConvex	*CPhysicsCollision::ConvexFromVertsFast( Vector **pVerts, int vertCount )
{
	IVP_U_Vector<IVP_U_Point> points;
	int i;

	for ( i = 0; i < vertCount; i++ )
	{
		IVP_U_Point *tmp = new IVP_U_Point;
		
		ConvertPositionToIVP( *pVerts[i], *tmp );

		BEGIN_IVP_ALLOCATION();
		points.add( tmp );
		END_IVP_ALLOCATION();
	}

	BEGIN_IVP_ALLOCATION();
	IVP_Compact_Ledge *pLedge = IVP_SurfaceBuilder_Pointsoup::convert_pointsoup_to_compact_ledge( &points );
	END_IVP_ALLOCATION();

	for ( i = 0; i < points.len(); i++ )
	{
		delete points.element_at(i);
	}
	points.clear();

	return reinterpret_cast<CPhysConvex *>(pLedge);
}

CPhysConvex *CPhysicsCollision::RebuildConvexFromPlanes( CPhysConvex *pConvex, float mergeTolerance )
{
	if ( !pConvex )
		return NULL;
	
	IVP_Compact_Ledge *pLedge = (IVP_Compact_Ledge *)pConvex;
	int triangleCount = pLedge->get_n_triangles();
	
	IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();
	IVP_U_Hesse plane;
    IVP_Halfspacesoup halfspaces;
	
	for ( int j = 0; j < triangleCount; j++ )
	{
		const IVP_Compact_Edge *pEdge = pTri->get_edge( 0 );
		const IVP_U_Float_Point *p0 = IVP_Compact_Ledge_Solver::give_object_coords(pEdge, pLedge);
		const IVP_U_Float_Point *p2 = IVP_Compact_Ledge_Solver::give_object_coords(pEdge->get_next(), pLedge);
		const IVP_U_Float_Point *p1 = IVP_Compact_Ledge_Solver::give_object_coords(pEdge->get_prev(), pLedge);
		plane.calc_hesse(p0, p2, p1);
		float testLen = plane.real_length();
		// if the triangle is less than 1mm on each side then skip it
		if ( testLen > 1e-6f )
		{
			plane.normize();
			halfspaces.add_halfspace( &plane );
		}
		
		pTri = pTri->get_next_tri();
	}
	
    IVP_Compact_Ledge *pLedgeOut = IVP_SurfaceBuilder_Halfspacesoup::convert_halfspacesoup_to_compact_ledge( &halfspaces, mergeTolerance );
	return reinterpret_cast<CPhysConvex *>( pLedgeOut );
}

CPhysConvex	*CPhysicsCollision::ConvexFromVerts( Vector **pVerts, int vertCount )
{
	CPhysConvex	*pConvex = ConvexFromVertsFast( pVerts, vertCount );
	CPhysConvex	*pReturn = RebuildConvexFromPlanes( pConvex, 0.01f );	// remove interior coplanar verts!
	if ( pReturn )
	{
		ConvexFree( pConvex );
		return pReturn;
	}
	return pConvex;
}

// produce a convex element from planes (csg of planes)
CPhysConvex	*CPhysicsCollision::ConvexFromPlanes( float *pPlanes, int planeCount, float mergeDistance )
{
	// NOTE: We're passing in planes with outward-facing normals
	// Ipion expects inward facing ones; we'll need to reverse plane directon
	struct listplane_t
	{
		float normal[3];
		float dist;
	};

	listplane_t *pList = (listplane_t *)pPlanes;
	IVP_U_Hesse plane;
    IVP_Halfspacesoup halfspaces;

	mergeDistance = ConvertDistanceToIVP( mergeDistance );

	for ( int i = 0; i < planeCount; i++ )
	{
		Vector tmp( -pList[i].normal[0], -pList[i].normal[1], -pList[i].normal[2] ); 
		ConvertPlaneToIVP( tmp, -pList[i].dist, plane );
		halfspaces.add_halfspace( &plane );
	}
	
    IVP_Compact_Ledge *pLedge = IVP_SurfaceBuilder_Halfspacesoup::convert_halfspacesoup_to_compact_ledge( &halfspaces, mergeDistance );
	return reinterpret_cast<CPhysConvex *>( pLedge );
}



CPhysConvex *CPhysicsCollision::ConvexFromConvexPolyhedron( const CPolyhedron &ConvexPolyhedron )
{
	IVP_Template_Polygon polyTemplate(ConvexPolyhedron.iVertexCount, ConvexPolyhedron.iLineCount, ConvexPolyhedron.iPolygonCount );

	//convert/copy coordinates
	for( int i = 0; i != ConvexPolyhedron.iVertexCount; ++i )
		ConvertPositionToIVP( ConvexPolyhedron.pVertices[i], polyTemplate.points[i] );

	//copy lines
	for( int i = 0; i != ConvexPolyhedron.iLineCount; ++i )
		polyTemplate.lines[i].set( ConvexPolyhedron.pLines[i].iPointIndices[0], ConvexPolyhedron.pLines[i].iPointIndices[1] );

	//copy polygons
	for( int i = 0; i != ConvexPolyhedron.iPolygonCount; ++i )
	{
		polyTemplate.surfaces[i].init_surface( ConvexPolyhedron.pPolygons[i].iIndexCount ); //num vertices in a convex polygon == num lines
		polyTemplate.surfaces[i].templ_poly = &polyTemplate;

		ConvertPositionToIVP( ConvexPolyhedron.pPolygons[i].polyNormal, polyTemplate.surfaces[i].normal );

		Polyhedron_IndexedLineReference_t *pLineReferences = &ConvexPolyhedron.pIndices[ConvexPolyhedron.pPolygons[i].iFirstIndex];
		for( int j = 0; j != ConvexPolyhedron.pPolygons[i].iIndexCount; ++j )
		{
			polyTemplate.surfaces[i].lines[j] = pLineReferences[j].iLineIndex;
			polyTemplate.surfaces[i].revert_line[j] = pLineReferences[j].iEndPointIndex;
		}
	}

	//final conversion
	IVP_Compact_Ledge *pLedge = IVP_SurfaceBuilder_Polygon_Convex::convert_template_to_ledge(&polyTemplate);

	//cleanup
	for( int i = 0; i != ConvexPolyhedron.iPolygonCount; ++i )
		polyTemplate.surfaces[i].close_surface();

	return reinterpret_cast<CPhysConvex *>(pLedge);
}





struct PolyhedronMesh_Triangle
{
	struct
	{
		int iPointIndices[2];
	} Edges[3];
};



//TODO: Optimize the returned polyhedron to get away from the triangulated mesh
CPolyhedron *CPhysicsCollision::PolyhedronFromConvex( CPhysConvex * const pConvex, bool bUseTempPolyhedron )
{
	IVP_Compact_Ledge *pLedge = (IVP_Compact_Ledge *)pConvex;
	int iTriangles = pLedge->get_n_triangles();

	PolyhedronMesh_Triangle *pTriangles = (PolyhedronMesh_Triangle *)stackalloc( iTriangles * sizeof( PolyhedronMesh_Triangle ) );
	
	int iHighestPointIndex = 0;
	const IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();
	for( int i = 0; i != iTriangles; ++i )
	{
		//reverse point ordering while creating edges
		pTriangles[i].Edges[2].iPointIndices[1] = pTriangles[i].Edges[0].iPointIndices[0] = pTri->get_edge( 2 )->get_start_point_index();
		pTriangles[i].Edges[0].iPointIndices[1] = pTriangles[i].Edges[1].iPointIndices[0] = pTri->get_edge( 1 )->get_start_point_index();
		pTriangles[i].Edges[1].iPointIndices[1] = pTriangles[i].Edges[2].iPointIndices[0] = pTri->get_edge( 0 )->get_start_point_index();

		for( int j = 0; j != 3; ++j )
		{
			//get_n_points() has a whole bunch of ifdefs that apparently disable it in this case, detect number of points
			if( pTriangles[i].Edges[j].iPointIndices[0] > iHighestPointIndex )
				iHighestPointIndex = pTriangles[i].Edges[j].iPointIndices[0];
		}
		
		pTri = pTri->get_next_tri();
	}

	++iHighestPointIndex;

	//apparently points might be shared between ledges and not all points will be used. So now we get to compress them into a smaller set
	int *pPointRemapping = (int *)stackalloc( iHighestPointIndex * sizeof( int ) );
	memset( pPointRemapping, 0, iHighestPointIndex * sizeof( int ) );
	for( int i = 0; i != iTriangles; ++i )
	{
		for( int j = 0; j != 3; ++j )
			++(pPointRemapping[pTriangles[i].Edges[j].iPointIndices[0]]);
	}

	int iInsertIndex = 0;

	for( int i = 0; i != iHighestPointIndex; ++i )
	{
		if( pPointRemapping[i] )
		{
			pPointRemapping[i] = iInsertIndex;
			++iInsertIndex;
		}
		else
		{
			pPointRemapping[i] = -1;
		}
	}

	const int iNumPoints = iInsertIndex;

	for( int i = 0; i != iTriangles; ++i )
	{
		for( int j = 0; j != 3; ++j )
		{
			for( int k = 0; k != 2; ++k )
				pTriangles[i].Edges[j].iPointIndices[k] = pPointRemapping[pTriangles[i].Edges[j].iPointIndices[k]];
		}
	}
	

	bool *bLinks = (bool *)stackalloc( iNumPoints * iNumPoints * sizeof( bool ) );
	memset( bLinks, 0, iNumPoints * iNumPoints * sizeof( bool ) );

	int iLinkCount = 0;
	for( int i = 0; i != iTriangles; ++i )
	{
		for( int j = 0; j != 3; ++j )
		{
			const int *pIndices = pTriangles[i].Edges[j].iPointIndices;
			int iLow = ((pIndices[0] > pIndices[1])?1:(0));
			++iLinkCount; //this will technically make the link count double the actual number
			bLinks[(pIndices[iLow] * iNumPoints) + pIndices[1-iLow]] = true;
		}
	}

	iLinkCount /= 2; //cut the link count in half since we overcounted

	CPolyhedron *pReturn;
	if( bUseTempPolyhedron )
		pReturn = GetTempPolyhedron( iNumPoints, iLinkCount, iLinkCount * 2, iTriangles );
	else
		pReturn = CPolyhedron_AllocByNew::Allocate( iNumPoints, iLinkCount, iLinkCount * 2, iTriangles );

	//copy/convert vertices
	const IVP_Compact_Poly_Point *pLedgePoints = pLedge->get_point_array();
	Vector *pWriteVertices = pReturn->pVertices;
	for( int i = 0; i != iHighestPointIndex; ++i )
	{
		if( pPointRemapping[i] != -1 )
			ConvertPositionToHL( pLedgePoints[i], pWriteVertices[pPointRemapping[i]] );
	}

    
	//convert lines
	iInsertIndex = 0;
	for( int i = 0; i != iNumPoints; ++i )
	{
		for( int j = i + 1; j != iNumPoints; ++j )
		{
			if( bLinks[(i * iNumPoints) + j] )
			{
				pReturn->pLines[iInsertIndex].iPointIndices[0] = i;
				pReturn->pLines[iInsertIndex].iPointIndices[1] = j;
				++iInsertIndex;
			}
		}
	}

	
	int *pStartIndices = (int *)stackalloc( iNumPoints * sizeof( int ) ); //for quicker lookup of which edges to use in polygons

	pStartIndices[0] = 0; //the lowest index point drives links, so if the first point isn't the first link, then something is extremely messed up
	Assert( pReturn->pLines[0].iPointIndices[0] == 0 );
	iInsertIndex = 1;
	for( int i = 1; i != iNumPoints; ++i )
	{
		for( int j = iInsertIndex; j != iLinkCount; ++j )
		{
			if( pReturn->pLines[j].iPointIndices[0] == i )
			{
				pStartIndices[i] = j;
				iInsertIndex = j + 1;
				break;
			}
		}
	}

	//convert polygons and setup line references as a subtask
	iInsertIndex = 0;
	for( int i = 0; i != iTriangles; ++i )
	{
		pReturn->pPolygons[i].iFirstIndex = iInsertIndex;
		pReturn->pPolygons[i].iIndexCount = 3;

		Vector *p1, *p2, *p3;
		p1 = &pReturn->pVertices[pTriangles[i].Edges[0].iPointIndices[0]];
		p2 = &pReturn->pVertices[pTriangles[i].Edges[1].iPointIndices[0]];
		p3 = &pReturn->pVertices[pTriangles[i].Edges[2].iPointIndices[0]];

		Vector v1to2, v1to3;

		v1to2 = *p2 - *p1;
		v1to3 = *p3 - *p1;

		pReturn->pPolygons[i].polyNormal = v1to3.Cross( v1to2 );
		pReturn->pPolygons[i].polyNormal.NormalizeInPlace();

		for( int j = 0; j != 3; ++j, ++iInsertIndex )
		{
			const int *pIndices = pTriangles[i].Edges[j].iPointIndices;
			int iLow = (pIndices[0] > pIndices[1])?1:0;
			int iLineIndex;
			for( iLineIndex = pStartIndices[pIndices[iLow]]; iLineIndex != iLinkCount; ++iLineIndex )
			{
				if( (pReturn->pLines[iLineIndex].iPointIndices[0] == pIndices[iLow]) &&
					(pReturn->pLines[iLineIndex].iPointIndices[1] == pIndices[1 - iLow]) )
				{
					break;
				}
			}

			pReturn->pIndices[iInsertIndex].iLineIndex = iLineIndex;
			pReturn->pIndices[iInsertIndex].iEndPointIndex = 1 - iLow;
		}
	}

	return pReturn;
}


int CPhysicsCollision::GetConvexesUsedInCollideable( const CPhysCollide *pCollideable, CPhysConvex **pOutputArray, int iOutputArrayLimit )
{
	IVP_U_BigVector<IVP_Compact_Ledge> ledges;
	pCollideable->GetAllLedges( ledges );

	int iLedgeCount = ledges.len();
	if( iLedgeCount > iOutputArrayLimit )
		iLedgeCount = iOutputArrayLimit;

	for( int i = 0; i != iLedgeCount; ++i )
	{
		IVP_Compact_Ledge *pLedge = ledges.element_at(i); //doing as a 2 step since a single convert seems more error prone (without compile error) in this case
		pOutputArray[i] = (CPhysConvex *)pLedge;
	}

	return iLedgeCount;
}

void CPhysicsCollision::ConvexesFromConvexPolygon( const Vector &vPolyNormal, const Vector *pPoints, int iPointCount, CPhysConvex **pOutput )
{
	IVP_U_Point *pIVP_Points = (IVP_U_Point *)stackalloc( sizeof( IVP_U_Point ) * iPointCount );
	IVP_U_Point **pTriangulator = (IVP_U_Point **)stackalloc( sizeof( IVP_U_Point * ) * iPointCount );
	IVP_U_Point **pRead = pTriangulator;
	IVP_U_Point **pWrite = pTriangulator;

	//convert coordinates
	{
		for( int i = 0; i != iPointCount; ++i )
			ConvertPositionToIVP( pPoints[i], pIVP_Points[i] );
	}

	int iOutputCount = 0;

	//chunk this out like a triangle strip
	int iForwardCounter = 1;
	int iReverseCounter = iPointCount - 1; //guaranteed to be >= 2 to start

	*pWrite = &pIVP_Points[0];
	++pWrite;
	*pWrite = &pIVP_Points[iReverseCounter];
	++pWrite;
	--iReverseCounter;

	do
	{
		//forward
		*pWrite = &pIVP_Points[iForwardCounter];
		++iForwardCounter;

		pOutput[iOutputCount] = reinterpret_cast<CPhysConvex *>(IVP_SurfaceBuilder_Pointsoup::convert_triangle_to_compace_ledge( pRead[0], pRead[1], pRead[2] ));
		Assert( pOutput[iOutputCount] );
		++iOutputCount;
		if( iForwardCounter > iReverseCounter )
			break;

		++pRead;
		++pWrite;



		//backward
		*pWrite = &pIVP_Points[iReverseCounter];
		--iReverseCounter;

		pOutput[iOutputCount] = reinterpret_cast<CPhysConvex *>(IVP_SurfaceBuilder_Pointsoup::convert_triangle_to_compace_ledge( pRead[0], pRead[1], pRead[2] ));
		Assert( pOutput[iOutputCount] );
		++iOutputCount;

		if( iForwardCounter > iReverseCounter )
			break;

		++pRead;
		++pWrite;
	} while( true );
}


//-----------------------------------------------------------------------------
// Purpose: copies the first vert int pLedge to out
// Input  : *pLedge - compact ledge
//			*out - destination float array for the vert
//-----------------------------------------------------------------------------
static void LedgeInsidePoint( IVP_Compact_Ledge *pLedge, Vector& out )
{
	IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();
	const IVP_Compact_Edge *pEdge = pTri->get_edge( 0 );
	const IVP_U_Float_Point *pPoint = pEdge->get_start_point( pLedge );
	ConvertPositionToHL( *pPoint, out );
}


//-----------------------------------------------------------------------------
// Purpose: Calculate the volume of a tetrahedron with these vertices
// Input  : p0 - points of tetrahedron
//			p1 - 
//			p2 - 
//			p3 - 
// Output : float (volume in units^3)
//-----------------------------------------------------------------------------
static float TetrahedronVolume( const Vector &p0, const Vector &p1, const Vector &p2, const Vector &p3 )
{
	Vector a, b, c, cross;
	float volume = 1.0f / 6.0f;

	a = p1 - p0;
	b = p2 - p0;
	c = p3 - p0;
	cross = CrossProduct( b, c );

	volume *= DotProduct( a, cross );
	if ( volume < 0 )
		return -volume;
	return volume;
}


static float TriangleArea( const Vector &p0, const Vector &p1, const Vector &p2 )
{
	Vector e0 = p1 - p0;
	Vector e1 = p2 - p0;
	Vector cross;

	CrossProduct( e0, e1, cross );
	return 0.5 * cross.Length();
}


//-----------------------------------------------------------------------------
// Purpose: Tetrahedronalize this ledge and compute it's volume in BSP space
// Input  : convex - the ledge
// Output : float - volume in HL units (in^3)
//-----------------------------------------------------------------------------
float CPhysicsCollision::ConvexVolume( CPhysConvex *pConvex )
{
	IVP_Compact_Ledge *pLedge = (IVP_Compact_Ledge *)pConvex;
	int triangleCount = pLedge->get_n_triangles();

	IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();

	Vector vert;
	float volume = 0;
	// vert is in HL units
	LedgeInsidePoint( pLedge, vert );

	for ( int j = 0; j < triangleCount; j++ )
	{
		Vector points[3];
		for ( int k = 0; k < 3; k++ )
		{
			const IVP_Compact_Edge *pEdge = pTri->get_edge( k );
			const IVP_U_Float_Point *pPoint = pEdge->get_start_point( pLedge );
			ConvertPositionToHL( *pPoint, points[k] );
		}
		volume += TetrahedronVolume( vert, points[0], points[1], points[2] );

		pTri = pTri->get_next_tri();
	}

	return volume;
}


float CPhysicsCollision::ConvexSurfaceArea( CPhysConvex *pConvex )
{
	IVP_Compact_Ledge *pLedge = (IVP_Compact_Ledge *)pConvex;
	int triangleCount = pLedge->get_n_triangles();

	IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();

	float area = 0;

	for ( int j = 0; j < triangleCount; j++ )
	{
		Vector points[3];
		for ( int k = 0; k < 3; k++ )
		{
			const IVP_Compact_Edge *pEdge = pTri->get_edge( k );
			const IVP_U_Float_Point *pPoint = pEdge->get_start_point( pLedge );
			ConvertPositionToHL( *pPoint, points[k] );
		}
		area += TriangleArea( points[0], points[1], points[2] );

		pTri = pTri->get_next_tri();
	}

	return area;
}

// Convert an array of convex elements to a compiled collision model (this deletes the convex elements)
CPhysCollide *CPhysicsCollision::ConvertConvexToCollide( CPhysConvex **pConvex, int convexCount )
{
	convertconvexparams_t convertParams;
	convertParams.Defaults();
	return ConvertConvexToCollideParams( pConvex, convexCount, convertParams );
}

CPhysCollide *CPhysicsCollision::ConvertConvexToCollideParams( CPhysConvex **pConvex, int convexCount, const convertconvexparams_t &convertParams )
{
	if ( !convexCount || !pConvex )
		return NULL;

	int validConvex = 0;
	BEGIN_IVP_ALLOCATION();
	IVP_SurfaceBuilder_Ledge_Soup builder;
	IVP_Compact_Surface *pSurface = NULL;

	for ( int i = 0; i < convexCount; i++ )
	{
		if ( pConvex[i] )
		{
			validConvex++;
			builder.insert_ledge( (IVP_Compact_Ledge *)pConvex[i] );
		}
	}
	// if the outside code does something stupid, don't crash
	if ( validConvex )
	{
		IVP_Template_Surbuild_LedgeSoup params;
		params.force_convex_hull = (IVP_Compact_Ledge *)convertParams.pForcedOuterHull;
		params.build_root_convex_hull = convertParams.buildOuterConvexHull ? IVP_TRUE : IVP_FALSE;

		// NOTE: THIS FREES THE LEDGES in pConvex!!!
		pSurface = builder.compile( &params );
		CPhysCollide *pCollide = new CPhysCollideCompactSurface( pSurface );
		if ( convertParams.buildDragAxisAreas )
		{
			pCollide->ComputeOrthographicAreas( convertParams.dragAreaEpsilon );
		}

		END_IVP_ALLOCATION();
		return pCollide;
	}

	END_IVP_ALLOCATION();

	return NULL;
}

static void InitBoxVerts( Vector *boxVerts, Vector **ppVerts, const Vector &mins, const Vector &maxs )
{
	for (int i = 0; i < 8; ++i)
	{
		boxVerts[i][0] = (i & 0x1) ? maxs[0] : mins[0];
		boxVerts[i][1] = (i & 0x2) ? maxs[1] : mins[1];
		boxVerts[i][2] = (i & 0x4) ? maxs[2] : mins[2];
		if ( ppVerts )
		{
			ppVerts[i] = &boxVerts[i];
		}
	}
}


#define FAST_BBOX 1
CPhysCollideCompactSurface *CPhysicsCollision::FastBboxCollide( const CPhysCollideCompactSurface *pCollide, const Vector &mins, const Vector &maxs )
{
	Vector boxVerts[8];
	InitBoxVerts( boxVerts, NULL, mins, maxs );
	// copy the compact ledge at bboxCache 0
	// stuff the verts in there
	const IVP_Compact_Surface *pSurface = ConvertPhysCollideToCompactSurface( pCollide );
	Assert( pSurface );
	const IVP_Compact_Ledgetree_Node *node = pSurface->get_compact_ledge_tree_root();
	Assert( node->is_terminal() == IVP_TRUE );
	const IVP_Compact_Ledge *pLedge = node->get_compact_ledge();
	int ledgeSize = pLedge->get_size();
	IVP_Compact_Ledge *pNewLedge = (IVP_Compact_Ledge *)ivp_malloc_aligned( ledgeSize, 16 );
	memcpy( pNewLedge, pLedge, ledgeSize );
	pNewLedge->set_client_data(0);
	IVP_Compact_Poly_Point *pPoints = pNewLedge->get_point_array();
	for ( int i = 0; i < 8; i++ )
	{
		IVP_U_Float_Hesse ivp;
		ConvertPositionToIVP( boxVerts[m_bboxVertMap[i]], ivp );
		ivp.hesse_val = 0;
		pPoints[i].set4(&ivp);
	}
	CPhysConvex *pConvex = (CPhysConvex *)pNewLedge;
	return (CPhysCollideCompactSurface *)ConvertConvexToCollide( &pConvex, 1 );
}

void CPhysicsCollision::InitBBoxCache()
{
	Vector boxVerts[8], *ppVerts[8];
	Vector mins(-16,-16,0), maxs(16,16,72);
	// init with the player box
	InitBoxVerts( boxVerts, ppVerts, mins, maxs );
	// Generate a convex hull from the verts
	CPhysConvex *pConvex = ConvexFromVertsFast( ppVerts, 8 );
	IVP_Compact_Poly_Point *pPoints = reinterpret_cast<IVP_Compact_Ledge *>(pConvex)->get_point_array();
	for ( int i = 0; i < 8; i++ )
	{
		int nearest = -1;
		float minDist = 0.1;
		Vector tmp;
		ConvertPositionToHL( pPoints[i], tmp );
		for ( int j = 0; j < 8; j++ )
		{
			float dist = (boxVerts[j] - tmp).Length();
			if ( dist < minDist )
			{
				minDist = dist;
				nearest = j;
			}
		}
		
		m_bboxVertMap[i] = nearest;

#if _DEBUG
		for ( int k = 0; k < i; k++ )
		{
			Assert( m_bboxVertMap[k] != m_bboxVertMap[i] );
		}
#endif
		// NOTE: If this is wrong, you can disable FAST_BBOX above to fix
		AssertMsg( nearest != -1, "CPhysCollide: Vert map is wrong\n" );
	}
	CPhysCollide *pCollide = ConvertConvexToCollide( &pConvex, 1 );
	AddBBoxCache( (CPhysCollideCompactSurface *)pCollide, mins, maxs );
}


CPhysConvex	*CPhysicsCollision::BBoxToConvex( const Vector &mins, const Vector &maxs )
{
	Vector boxVerts[8], *ppVerts[8];
	InitBoxVerts( boxVerts, ppVerts, mins, maxs );
	// Generate a convex hull from the verts
	return ConvexFromVertsFast( ppVerts, 8 );
}

CPhysCollide *CPhysicsCollision::BBoxToCollide( const Vector &mins, const Vector &maxs )
{
	printf("BBoxToCollide\n");

	// can't create a collision model for an empty box !
	if ( mins == maxs )
	{
		Assert(0);
		return NULL;
	}

	// find this bbox in the cache
	CPhysCollide *pCollide = GetBBoxCache( mins, maxs );
	if ( pCollide )
		return pCollide;

	// FAST_BBOX: uses an existing compact ledge as a template for fast generation
	// building convex hulls from points is slow
#if FAST_BBOX
	if ( m_bboxCache.Count() == 0 )
	{
		InitBBoxCache();
	}
	pCollide = FastBboxCollide( m_bboxCache[0].pCollide, mins, maxs );
#else
	CPhysConvex *pConvex = BBoxToConvex( mins, maxs );
	pCollide = ConvertConvexToCollide( &pConvex, 1 );
#endif
	AddBBoxCache( (CPhysCollideCompactSurface *)pCollide, mins, maxs );
	return pCollide;
}

bool CPhysicsCollision::IsBBoxCache( CPhysCollide *pCollide )
{
	// UNDONE: Sort the list so it can be searched spatially instead of linearly?
	for ( int i = m_bboxCache.Count()-1; i >= 0; i-- )
	{
		if ( m_bboxCache[i].pCollide == pCollide )
			return true;
	}
	return false;
}

void CPhysicsCollision::AddBBoxCache( CPhysCollideCompactSurface *pCollide, const Vector &mins, const Vector &maxs )
{
	int index = m_bboxCache.AddToTail();
	bboxcache_t *pCache = &m_bboxCache[index];
	pCache->pCollide = pCollide;
	pCache->mins = mins;
	pCache->maxs = maxs;
}

CPhysCollideCompactSurface *CPhysicsCollision::GetBBoxCache( const Vector &mins, const Vector &maxs )
{
	for ( int i = m_bboxCache.Count()-1; i >= 0; i-- )
	{
		if ( m_bboxCache[i].mins == mins && m_bboxCache[i].maxs == maxs )
			return m_bboxCache[i].pCollide;
	}
	return NULL;
}


void CPhysicsCollision::ConvexFree( CPhysConvex *pConvex )
{
	if ( !pConvex )
		return;
	ivp_free_aligned( pConvex );
}

// Get the size of the collision model for serialization
int	CPhysicsCollision::CollideSize( CPhysCollide *pCollide )
{
	return pCollide->GetSerializationSize();
}

int	CPhysicsCollision::CollideWrite( char *pDest, CPhysCollide *pCollide, bool bSwap )
{
	return pCollide->SerializeToBuffer( pDest, bSwap );
}

CPhysCollide *CPhysicsCollision::UnserializeCollide( char *pBuffer, int size, int index )
{
	return NULL;
//	return CPhysCollide::UnserializeFromBuffer( pBuffer, size, index );
}

class CPhysPolysoup
{
public:
	CPhysPolysoup();
#if ENABLE_IVP_MOPP
	IVP_SurfaceBuilder_Mopp m_builder;
#endif
	IVP_SurfaceBuilder_Ledge_Soup m_builderSoup;
	IVP_U_Vector<IVP_U_Point> m_points;
	IVP_U_Point m_triangle[3];

	bool m_isValid;
};

CPhysPolysoup::CPhysPolysoup()
{
	m_isValid = false;
    m_points.add( &m_triangle[0] );
    m_points.add( &m_triangle[1] );
    m_points.add( &m_triangle[2] );
}

CPhysPolysoup *CPhysicsCollision::PolysoupCreate( void )
{
	return new CPhysPolysoup;
}

void CPhysicsCollision::PolysoupDestroy( CPhysPolysoup *pSoup )
{
	delete pSoup;
}

void CPhysicsCollision::PolysoupAddTriangle( CPhysPolysoup *pSoup, const Vector &a, const Vector &b, const Vector &c, int materialIndex7bits )
{
	pSoup->m_isValid = true;
	ConvertPositionToIVP( a, pSoup->m_triangle[0] );
	ConvertPositionToIVP( b, pSoup->m_triangle[1] );
	ConvertPositionToIVP( c, pSoup->m_triangle[2] );
	IVP_Compact_Ledge *pLedge = IVP_SurfaceBuilder_Pointsoup::convert_pointsoup_to_compact_ledge(&pSoup->m_points);
	if ( !pLedge )
	{
		Warning("Degenerate Triangle\n");
		Warning("(%.2f, %.2f, %.2f), ", a.x, a.y, a.z );
		Warning("(%.2f, %.2f, %.2f), ", b.x, b.y, b.z );
		Warning("(%.2f, %.2f, %.2f)\n", c.x, c.y, c.z );
		return;
	}
	IVP_Compact_Triangle *pTriangle = pLedge->get_first_triangle();
	pTriangle->set_material_index( materialIndex7bits );
#if ENABLE_IVP_MOPP
	pSoup->m_builder.insert_ledge(pLedge);
#endif
	pSoup->m_builderSoup.insert_ledge(pLedge);
}

CPhysCollide *CPhysicsCollision::ConvertPolysoupToCollide( CPhysPolysoup *pSoup, bool useMOPP )
{
	if ( !pSoup->m_isValid )
		return NULL;

	CPhysCollide *pCollide = NULL;
#if ENABLE_IVP_MOPP
	if ( useMOPP )
	{
	    IVP_Compact_Mopp *pSurface = pSoup->m_builder.compile();
		pCollide = new CPhysCollideMopp( pSurface );
	}
	else
#endif
	{
	    IVP_Compact_Surface *pSurface = pSoup->m_builderSoup.compile();
		pCollide = new CPhysCollideCompactSurface( pSurface );
	}

	Assert(pCollide);

	// There's a bug in IVP where the duplicated triangles (for 2D)
	// don't get the materials set properly, so copy them
	IVP_U_BigVector<IVP_Compact_Ledge> ledges;
	pCollide->GetAllLedges( ledges );

	for ( int i = 0; i < ledges.len(); i++ )
	{
		IVP_Compact_Ledge *pLedge = ledges.element_at( i );
		int triangleCount = pLedge->get_n_triangles();

		IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();
		int materialIndex = pTri->get_material_index();
		if ( !materialIndex )
		{
			for ( int j = 0; j < triangleCount; j++ )
			{
				if ( pTri->get_material_index() != 0 )
				{
					materialIndex = pTri->get_material_index();
				}
				pTri = pTri->get_next_tri();
			}
		}
		for ( int j = 0; j < triangleCount; j++ )
		{
			pTri->set_material_index( materialIndex );
			pTri = pTri->get_next_tri();
		}
	}

	return pCollide;
}

int CPhysicsCollision::CreateDebugMesh( const CPhysCollide *pCollisionModel, Vector **outVerts )
{
	int i;

	IVP_U_BigVector<IVP_Compact_Ledge> ledges;
	pCollisionModel->GetAllLedges( ledges );

	int vertCount = 0;
	
	for ( i = 0; i < ledges.len(); i++ )
	{
		IVP_Compact_Ledge *pLedge = ledges.element_at( i );
		vertCount += pLedge->get_n_triangles() * 3;
	}
	Vector *verts = new Vector[ vertCount ];
		
	int vertIndex = 0;
	for ( i = 0; i < ledges.len(); i++ )
	{
		IVP_Compact_Ledge *pLedge = ledges.element_at( i );
		int triangleCount = pLedge->get_n_triangles();

		IVP_Compact_Triangle *pTri = pLedge->get_first_triangle();
		for ( int j = 0; j < triangleCount; j++ )
		{
			for ( int k = 2; k >= 0; k-- )
			{
				const IVP_Compact_Edge *pEdge = pTri->get_edge( k );
				const IVP_U_Float_Point *pPoint = pEdge->get_start_point( pLedge );

				Vector* pVec = verts + vertIndex;
				ConvertPositionToHL( *pPoint, *pVec );
				vertIndex++;
			}
			pTri = pTri->get_next_tri();
		}
	}

	*outVerts = verts;
	return vertCount;
}


void CPhysicsCollision::DestroyDebugMesh( int vertCount, Vector *outVerts )
{
	delete[] outVerts;
}


void CPhysicsCollision::SetConvexGameData( CPhysConvex *pConvex, unsigned int gameData )
{
	IVP_Compact_Ledge *pLedge = reinterpret_cast<IVP_Compact_Ledge *>( pConvex );
	pLedge->set_client_data( gameData );
}


void CPhysicsCollision::TraceBox( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr )
{
	m_traceapi.SweepBoxIVP( start, end, mins, maxs, pCollide, collideOrigin, collideAngles, ptr );
}

void CPhysicsCollision::TraceBox( const Ray_t &ray, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr )
{
	TraceBox( ray, MASK_ALL, NULL, pCollide, collideOrigin, collideAngles, ptr );
}

void CPhysicsCollision::TraceBox( const Ray_t &ray, unsigned int contentsMask, IConvexInfo *pConvexInfo, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr )
{
	m_traceapi.SweepBoxIVP( ray, contentsMask, pConvexInfo, pCollide, collideOrigin, collideAngles, ptr );
}

// Trace one collide against another
void CPhysicsCollision::TraceCollide( const Vector &start, const Vector &end, const CPhysCollide *pSweepCollide, const QAngle &sweepAngles, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, trace_t *ptr )
{
	m_traceapi.SweepIVP( start, end, pSweepCollide, sweepAngles, pCollide, collideOrigin, collideAngles, ptr );
}

void CPhysicsCollision::CollideGetAABB( Vector *pMins, Vector *pMaxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles )
{
	m_traceapi.GetAABB( pMins, pMaxs, pCollide, collideOrigin, collideAngles );
}


Vector CPhysicsCollision::CollideGetExtent( const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, const Vector &direction )
{
	if ( !pCollide )
		return collideOrigin;

	return m_traceapi.GetExtent( pCollide, collideOrigin, collideAngles, direction );
}

bool CPhysicsCollision::IsBoxIntersectingCone( const Vector &boxAbsMins, const Vector &boxAbsMaxs, const truncatedcone_t &cone )
{
	return m_traceapi.IsBoxIntersectingCone( boxAbsMins, boxAbsMaxs, cone );
}

// Free a collide that was created with ConvertConvexToCollide()
void CPhysicsCollision::DestroyCollide( CPhysCollide *pCollide )
{
	if ( !IsBBoxCache( pCollide ) )
	{
		delete pCollide;
	}
}

// calculate the volume of a collide by calling ConvexVolume on its parts
float CPhysicsCollision::CollideVolume( CPhysCollide *pCollide )
{
	IVP_U_BigVector<IVP_Compact_Ledge> ledges;
	pCollide->GetAllLedges( ledges );

	float volume = 0;
	for ( int i = 0; i < ledges.len(); i++ )
	{
		volume += ConvexVolume( (CPhysConvex *)ledges.element_at(i) );
	}

	return volume;
}

// calculate the volume of a collide by calling ConvexVolume on its parts
float CPhysicsCollision::CollideSurfaceArea( CPhysCollide *pCollide )
{
	IVP_U_BigVector<IVP_Compact_Ledge> ledges;
	pCollide->GetAllLedges( ledges );

	float area = 0;
	for ( int i = 0; i < ledges.len(); i++ )
	{
		area += ConvexSurfaceArea( (CPhysConvex *)ledges.element_at(i) );
	}

	return area;
}

PxShape *IVPLedgeToConvexShape( const ivp_compat::compactledge_t *pLedge )
{
	if ( !pLedge->n_triangles )
		return nullptr;

	const char *pVertices = reinterpret_cast< const char * >( pLedge ) + pLedge->c_point_offset;
	const ivp_compat::compacttriangle_t *pTriangles = reinterpret_cast< const ivp_compat::compacttriangle_t * >( pLedge + 1 );

	const int nVertCount = pLedge->n_triangles * 3;

	CArrayAutoPtr<PxVec3> convexVerts(new PxVec3[nVertCount]);

	// Each triangle
	for ( int i = 0; i < pLedge->n_triangles; i++ )
	{
		// For each point of the current triangle
		for ( int j = 0; j < 3; j++ )
		{
			static constexpr size_t IVPAlignedVectorSize = 16;

			const int nIndex = pTriangles[ i ].c_three_edges[ j ].start_point_index;
			const float *pVertex = reinterpret_cast< const float * >( pVertices + ( nIndex * IVPAlignedVectorSize ) );

			convexVerts[ ( i * 3 ) + j ] = PxVec3( IVP2HL(pVertex[0]), IVP2HL(pVertex[2]), -IVP2HL(pVertex[1]) );
		}
	}

	PxConvexMeshDesc convexDesc;
	convexDesc.points.count = nVertCount;
	convexDesc.points.stride = sizeof(PxVec3);
	convexDesc.points.data = convexVerts.Get();
	convexDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;

	PxDefaultMemoryOutputStream buf;
	PxConvexMeshCookingResult::Enum result;
	if(!gPxCooking->cookConvexMesh(convexDesc, buf, &result))
	    return NULL;

	PxDefaultMemoryInputData input(buf.getData(), buf.getSize());
	PxConvexMesh* convexMesh = gPxPhysics->createConvexMesh(input);

	PxMaterial *mat = gPxPhysics->createMaterial(0.5f, 0.5f, 0.6f);
	PxShape *shape = gPxPhysics->createShape( PxConvexMeshGeometry(convexMesh), *mat );

	if( shape )
		Msg("Cooking success %u!\n", convexMesh->getNbVertices());

	//pConvexShape->SetUserData( pLedge->client_data );
	return shape;
}


static void GetAllIVPEdges(const ivp_compat::compactledgenode_t *pNode, CUtlVector<const ivp_compat::compactledge_t *> *vecOut)
{
	if (!pNode || !vecOut) return;

	if ( !pNode->IsTerminal() )
	{
		GetAllIVPEdges( pNode->GetRightChild(), vecOut );
		GetAllIVPEdges( pNode->GetLeftChild(), vecOut );
	}
	else
		vecOut->AddToTail( pNode->GetCompactLedge() );
}

CPhysCollide *DeserializeIVP_Poly( const ivp_compat::compactsurface_t* pSurface )
{
	const ivp_compat::compactledgenode_t *pFirstLedgeNode = reinterpret_cast< const ivp_compat::compactledgenode_t * >(
			reinterpret_cast< const char * >( pSurface ) + pSurface->offset_ledgetree_root );

	CUtlVector< const ivp_compat::compactledge_t * > ledges;
	GetAllIVPEdges( pFirstLedgeNode, &ledges );

//	if( ledges.Count() <= 5 )
//		return NULL;

	PxShape *mesh = IVPLedgeToConvexShape( ledges[0] );
	mesh->userData = NULL;

	if( ledges.Count() == 1 )
		return new CPhysCollidePx( mesh );

//	if( ledges.Count() > 5 )
//		return NULL;

	PxShape *prevMesh = mesh;
	for( int i = 1; i < ledges.Count(); i++ )
	{
		PxShape *nextMesh = IVPLedgeToConvexShape( ledges[i] );
		prevMesh->userData = nextMesh;
		prevMesh = nextMesh;
	}

	return new CPhysCollidePx( mesh );
}

CPhysCollide *DeserializeIVP_Poly( const ivp_compat::collideheader_t *pCollideHeader )
{
	const ivp_compat::compactsurfaceheader_t *pSurfaceHeader = reinterpret_cast< const ivp_compat::compactsurfaceheader_t* >( pCollideHeader + 1 );
	const ivp_compat::compactsurface_t *pSurface = reinterpret_cast< const ivp_compat::compactsurface_t* >( pSurfaceHeader + 1 );
	return DeserializeIVP_Poly( pSurface );
}

// loads a set of solids into a vcollide_t
void CPhysicsCollision::VCollideLoad( vcollide_t *pOutput, int solidCount, const char *pBuffer, int bufferSize, bool swap )
{
	memset( pOutput, 0, sizeof(*pOutput) );

	pOutput->solidCount = solidCount;
	pOutput->solids = new CPhysCollide*[ solidCount ];

	const char *pCursor = pBuffer;
	for ( int i = 0; i < solidCount; i++ )
	{
		// Be safe ahead of time as so much can go wrong with
		// this mess! :p
		pOutput->solids[ i ] = nullptr;

		const int solidSize = *reinterpret_cast<const int *>( pCursor );
		pCursor += sizeof( int );

		const ivp_compat::collideheader_t *pCollideHeader = reinterpret_cast<const ivp_compat::collideheader_t *>( pCursor );

		if ( pCollideHeader->vphysicsID == VPHYSICS_COLLISION_ID )
		{
			// This is the main path that everything falls down for a modern
			// .phy file with the collide header.

			if ( pCollideHeader->version != VPHYSICS_COLLISION_VERSION )
				Warning( "Solid with unknown version: 0x%x, may crash!\n", pCollideHeader->version );

			CPhysCollide *collide;
			switch ( pCollideHeader->modelType )
			{
				case COLLIDE_POLY:
					collide = DeserializeIVP_Poly( pCollideHeader );
					pOutput->solids[ i ] = collide;
					break;
				default:
					Warning( "Unsupported solid type 0x%x on solid %d. Skipping...\n", (int)pCollideHeader->modelType, i );
					break;
			}
		}
		else
		{
			// This must be a legacy style .phy where it is just a dumped compact surface.
			// Some props in shipping HL2 still use this format, as they have a .phy, even after their
			// .qc had the $collisionmodel removed, as they didn't get the stale .phy in the game files deleted.

			const ivp_compat::compactsurface_t *pCompactSurface = reinterpret_cast<const ivp_compat::compactsurface_t*>( pCursor );
			const int legacyModelType = pCompactSurface->dummy[2];
			switch ( legacyModelType )
			{
				case 0:
				case IVP_COMPACT_SURFACE_ID:
				case IVP_COMPACT_SURFACE_ID_SWAPPED:
					pOutput->solids[i] = DeserializeIVP_Poly( pCollideHeader );
					break;
				default:
					Warning( "Unsupported legacy solid type 0x%x on solid %d. Skipping...\n", legacyModelType, i);
					break;
			}
		}

		pCursor += solidSize;
	}

	// The rest of the buffer is KV.
	const int keyValuesSize = bufferSize - ( pCursor - pBuffer );

	pOutput->pKeyValues = new char[ keyValuesSize + 1 ];
	V_memcpy( pOutput->pKeyValues, pCursor, keyValuesSize );
	pOutput->pKeyValues[ keyValuesSize ] = '\0';

	pOutput->descSize = keyValuesSize;
	pOutput->isPacked = false;
#ifdef GAME_ASW_OR_NEWER
	pOutput->pUserData = nullptr;
#endif
}

// destroys the set of solids created by VCollideCreateCPhysCollide
void CPhysicsCollision::VCollideUnload( vcollide_t *pVCollide )
{
	for ( int i = 0; i < pVCollide->solidCount; i++ )
	{
#if _DEBUG
		// HACKHACK: 1024 is just "some big number"
		// GetActiveEnvironmentByIndex() will eventually return NULL when there are no more environments.
		// In HL2 & TF2, there are only 2 environments - so j > 1 is probably an error!
		for ( int j = 0; j < 1024; j++ )
		{
			IPhysicsEnvironment *pEnv = g_PhysicsInternal->GetActiveEnvironmentByIndex( j );
			if ( !pEnv )
				break;

			if ( pEnv->IsCollisionModelUsed( (CPhysCollide *)pVCollide->solids[i] ) )
			{
 				AssertMsg(0, "Freed collision model while in use!!!\n");
				return;
			}
		}
#endif
		delete pVCollide->solids[i];
	}
	delete[] pVCollide->solids;
	delete[] pVCollide->pKeyValues;
	memset( pVCollide, 0, sizeof(*pVCollide) );
}

// begins parsing a vcollide.  NOTE: This keeps pointers to the vcollide_t
// If you delete the vcollide_t and call members of IVCollideParse, it will crash
IVPhysicsKeyParser *CPhysicsCollision::VPhysicsKeyParserCreate( const char *pKeyData )
{
	return CreateVPhysicsKeyParser( pKeyData );
}

// Free the parser created by VPhysicsKeyParserCreate
void CPhysicsCollision::VPhysicsKeyParserDestroy( IVPhysicsKeyParser *pParser )
{
	DestroyVPhysicsKeyParser( pParser );
}

IPhysicsCollision *CPhysicsCollision::ThreadContextCreate( void )
{ 
	return this;
}

void CPhysicsCollision::ThreadContextDestroy( IPhysicsCollision *pThreadContext )
{
}


void CPhysicsCollision::CollideGetMassCenter( CPhysCollide *pCollide, Vector *pOutMassCenter )
{
	*pOutMassCenter = pCollide->GetMassCenter();
}

void CPhysicsCollision::CollideSetMassCenter( CPhysCollide *pCollide, const Vector &massCenter )
{
	pCollide->SetMassCenter( massCenter );
}

int CPhysicsCollision::CollideIndex( const CPhysCollide *pCollide )
{
	if ( !pCollide )
		return 0;
	return pCollide->GetVCollideIndex();
}

Vector CPhysicsCollision::CollideGetOrthographicAreas( const CPhysCollide *pCollide )
{
	if ( !pCollide )
		return vec3_origin;
	return pCollide->GetOrthographicAreas();
}

void CPhysicsCollision::CollideSetOrthographicAreas( CPhysCollide *pCollide, const Vector &areas )
{
	if ( pCollide )
		pCollide->SetOrthographicAreas( areas );
}

// returns true if this collide has an outer hull built
void CPhysicsCollision::OutputDebugInfo( const CPhysCollide *pCollide )
{
	pCollide->OutputDebugInfo();
}

bool CPhysicsCollision::GetBBoxCacheSize( int *pCachedSize, int *pCachedCount )
{
	*pCachedSize = 0;
	*pCachedCount = m_bboxCache.Count();
	for ( int i = 0; i < *pCachedCount; i++ )
	{
		*pCachedSize += m_bboxCache[i].pCollide->GetSerializationSize();
	}
	return true;
}

class CCollisionQuery : public ICollisionQuery
{
public:
	CCollisionQuery( CPhysCollide *pCollide );
	~CCollisionQuery( void ) {}

	// number of convex pieces in the whole solid
	virtual int		ConvexCount( void );
	// triangle count for this convex piece
	virtual int		TriangleCount( int convexIndex );
	
	// get the stored game data
	virtual unsigned int GetGameData( int convexIndex );

	// Gets the triangle's verts to an array
	virtual void	GetTriangleVerts( int convexIndex, int triangleIndex, Vector *verts );
	
	// UNDONE: This doesn't work!!!
	virtual void	SetTriangleVerts( int convexIndex, int triangleIndex, const Vector *verts );
	
	// returns the 7-bit material index
	virtual int		GetTriangleMaterialIndex( int convexIndex, int triangleIndex );
	// sets a 7-bit material index for this triangle
	virtual void	SetTriangleMaterialIndex( int convexIndex, int triangleIndex, int index7bits );

private:
	IVP_Compact_Triangle *Triangle( IVP_Compact_Ledge *pLedge, int triangleIndex );

	IVP_U_BigVector <IVP_Compact_Ledge> m_ledges;
};


// create a queryable version of the collision model
ICollisionQuery *CPhysicsCollision::CreateQueryModel( CPhysCollide *pCollide )
{
	return new CCollisionQuery( pCollide );
}

	// destroy the queryable version
void CPhysicsCollision::DestroyQueryModel( ICollisionQuery *pQuery )
{
	delete pQuery;
}


CCollisionQuery::CCollisionQuery( CPhysCollide *pCollide )
{
	pCollide->GetAllLedges( m_ledges );
}


	// number of convex pieces in the whole solid
int	CCollisionQuery::ConvexCount( void )
{
	return m_ledges.len();
}

	// triangle count for this convex piece
int CCollisionQuery::TriangleCount( int convexIndex )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at(convexIndex);
	if ( pLedge )
	{
		return pLedge->get_n_triangles();
	}

	return 0;
}


unsigned int CCollisionQuery::GetGameData( int convexIndex )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at( convexIndex );
	if ( pLedge )
		return pLedge->get_client_data();
	return 0;
}

	// Gets the triangle's verts to an array
void CCollisionQuery::GetTriangleVerts( int convexIndex, int triangleIndex, Vector *verts )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at( convexIndex );
	IVP_Compact_Triangle *pTriangle = Triangle( pLedge, triangleIndex );

	int vertIndex = 0;
	for ( int k = 2; k >= 0; k-- )
	{
		const IVP_Compact_Edge *pEdge = pTriangle->get_edge( k );
		const IVP_U_Float_Point *pPoint = pEdge->get_start_point( pLedge );

		Vector* pVec = verts + vertIndex;
		ConvertPositionToHL( *pPoint, *pVec );
		vertIndex++;
	}
}

// UNDONE: This doesn't work!!!
void CCollisionQuery::SetTriangleVerts( int convexIndex, int triangleIndex, const Vector *verts )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at( convexIndex );
	Triangle( pLedge, triangleIndex );
}

	
int CCollisionQuery::GetTriangleMaterialIndex( int convexIndex, int triangleIndex )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at( convexIndex );
	IVP_Compact_Triangle *pTriangle = Triangle( pLedge, triangleIndex );

	return pTriangle->get_material_index();
}

void CCollisionQuery::SetTriangleMaterialIndex( int convexIndex, int triangleIndex, int index7bits )
{
	IVP_Compact_Ledge *pLedge = m_ledges.element_at( convexIndex );
	IVP_Compact_Triangle *pTriangle = Triangle( pLedge, triangleIndex );

	pTriangle->set_material_index( index7bits );
}

IVP_Compact_Triangle *CCollisionQuery::Triangle( IVP_Compact_Ledge *pLedge, int triangleIndex )
{
	if ( !pLedge )
		return NULL;

	return pLedge->get_first_triangle() + triangleIndex;
}


#if 0
void TestCubeVolume( void )
{
	float volume = 0;
	Vector verts[8];
	typedef struct 
	{
		int a, b, c;
	} triangle_t;

	triangle_t triangles[12] = 
	{
		{0,1,3}, // front	0123
		{0,3,2},
		{4,5,1}, // top		4501
		{4,1,0},
		{2,3,7}, // bottom	2367
		{2,7,6},
		{1,5,7}, // right	1537
		{1,7,3},
		{4,0,2}, // left	4062
		{4,2,6},
		{5,4,6}, // back	5476
		{5,6,7}
	};

	int i = 0;
	for ( int x = -1; x <= 1; x +=2 )
		for ( int y = -1; y <= 1; y +=2 )
			for ( int z = -1; z <= 1; z +=2 )
			{
				verts[i][0] = x;
				verts[i][1] = y;
				verts[i][2] = z;
				i++;
			}


	for ( i = 0; i < 12; i++ )
	{
		triangle_t *pTri = triangles + i;
		volume += TetrahedronVolume( verts[0], verts[pTri->a], verts[pTri->b], verts[pTri->c] );
	}
	// should report a volume of 8.  This is a cube that is 2 on a side
	printf("Test volume %.4f\n", volume );
}
#endif