1 files changed, 244 insertions, 0 deletions
diff --git a/vphysics/physics_trace.h b/vphysics/physics_trace.h
new file mode 100644
index 0000000..ca24d76
--- /dev/null
+++ b/vphysics/physics_trace.h
@@ -0,0 +1,244 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PHYSICS_TRACE_H
+#define PHYSICS_TRACE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+class Vector;
+class QAngle;
+class CGameTrace;
+class CTraceRay;
+class IVP_Compact_Surface;
+typedef CGameTrace trace_t;
+struct Ray_t;
+class IVP_Compact_Surface;
+class IVP_Compact_Mopp;
+class IConvexInfo;
+enum
+{
+	COLLIDE_POLY = 0,
+	COLLIDE_MOPP = 1,
+	COLLIDE_BALL = 2,
+	COLLIDE_VIRTUAL = 3,
+};
+
+class IPhysCollide
+{
+public:
+	virtual ~IPhysCollide() {}
+	//virtual void AddReference() = 0;
+	//virtual void ReleaseReference() = 0;
+
+	// get a surface manager 
+	virtual IVP_SurfaceManager *CreateSurfaceManager( short & ) const = 0;
+	virtual void GetAllLedges( IVP_U_BigVector<IVP_Compact_Ledge> &ledges ) const = 0;
+	virtual unsigned int GetSerializationSize() const = 0;
+	virtual unsigned int SerializeToBuffer( char *pDest, bool bSwap = false ) const = 0;
+	virtual int GetVCollideIndex() const = 0;
+	virtual Vector GetMassCenter() const = 0;
+	virtual void SetMassCenter( const Vector &massCenter ) = 0;
+	virtual Vector GetOrthographicAreas() const = 0;
+	virtual void SetOrthographicAreas( const Vector &areas ) = 0;
+	virtual float GetSphereRadius() const = 0;
+	virtual void OutputDebugInfo() const = 0;
+};
+
+#define LEAFMAP_HAS_CUBEMAP					0x0001
+#define LEAFMAP_HAS_SINGLE_VERTEX_SPAN		0x0002
+#define LEAFMAP_HAS_MULTIPLE_VERTEX_SPANS	0x0004
+struct leafmap_t
+{
+	void *pLeaf;
+	unsigned short vertCount;
+	byte	flags;
+	byte	spanCount;
+	unsigned short startVert[8];
+
+	void SetHasCubemap()
+	{
+		flags = LEAFMAP_HAS_CUBEMAP;
+	}
+
+	void SetSingleVertexSpan( int startVertIndex, int vertCountIn )
+	{
+		flags = 0;
+		flags |= LEAFMAP_HAS_SINGLE_VERTEX_SPAN;
+		startVert[0] = startVertIndex;
+		vertCount = vertCountIn;
+	}
+
+	int MaxSpans()
+	{
+		return sizeof(startVert) - sizeof(startVert[0]);
+	}
+	const byte *GetSpans() const
+	{
+		return reinterpret_cast<const byte *>(&startVert[1]);
+	}
+	byte *GetSpans()
+	{
+		return reinterpret_cast<byte *>(&startVert[1]);
+	}
+
+	void SetRLESpans( int startVertIndex, int spanCountIn, byte *pSpans )
+	{
+		flags = 0;
+		if ( spanCountIn > MaxSpans() )
+			return;
+		if ( spanCountIn == 1 )
+		{
+			SetSingleVertexSpan( startVertIndex, pSpans[0] );
+			return;
+		}
+		// write out a run length encoded list of verts to include in this model
+		flags |= LEAFMAP_HAS_MULTIPLE_VERTEX_SPANS;
+		startVert[0] = startVertIndex;
+		vertCount = 0;
+		spanCount = spanCountIn;
+		byte *pSpanOut = GetSpans();
+		for ( int i = 0; i < spanCountIn; i++ )
+		{
+			pSpanOut[i] = pSpans[i];
+			if ( !(i & 1) )
+			{
+				vertCount += pSpans[i];
+			}
+		}
+	}
+
+	inline bool HasSpans() const { return (flags & (LEAFMAP_HAS_SINGLE_VERTEX_SPAN|LEAFMAP_HAS_MULTIPLE_VERTEX_SPANS)) ? true : false; }
+	inline bool HasCubemap() const { return (flags & LEAFMAP_HAS_CUBEMAP) ? true : false; }
+	inline bool HasSingleVertexSpan() const { return (flags & LEAFMAP_HAS_SINGLE_VERTEX_SPAN) ? true : false; }
+	inline bool HasRLESpans() const { return (flags & LEAFMAP_HAS_MULTIPLE_VERTEX_SPANS) ? true : false; }
+};
+
+struct collidemap_t
+{
+	int				leafCount;
+	leafmap_t		leafmap[1];
+};
+
+extern void InitLeafmap( IVP_Compact_Ledge *pLeaf, leafmap_t *pLeafmapOut );
+
+class CPhysCollide : public IPhysCollide
+{
+public:
+	static CPhysCollide *UnserializeFromBuffer( const char *pBuffer, unsigned int size, int index, bool swap = false );
+	virtual const IVP_Compact_Surface *GetCompactSurface() const { return NULL; }
+	virtual Vector GetOrthographicAreas() const { return Vector(1,1,1); }
+	virtual float GetSphereRadius() const { return 0; }
+	virtual void ComputeOrthographicAreas( float epsilon ) {}
+	virtual void SetOrthographicAreas( const Vector &areas ) {}
+	virtual const collidemap_t *GetCollideMap() const { return NULL; }
+};
+
+class ITraceObject
+{
+public:
+	virtual int SupportMap( const Vector &dir, Vector *pOut ) const = 0;
+	virtual Vector GetVertByIndex( int index ) const = 0;
+	virtual float Radius( void ) const = 0;
+};
+
+// This is the size of the vertex hash
+#define CONVEX_HASH_SIZE		512
+// The little hashing trick below allows 64K verts per hash entry
+#define	MAX_CONVEX_VERTS		((CONVEX_HASH_SIZE * (1<<16))-1)
+
+class CPhysicsTrace
+{
+public:
+	CPhysicsTrace();
+	~CPhysicsTrace();
+	// Calculate the intersection of a swept box (mins/maxs) against an IVP object.  All coords are in HL space.
+	void SweepBoxIVP( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, const CPhysCollide *pSurface, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr );
+	void SweepBoxIVP( const Ray_t &raySrc, unsigned int contentsMask, IConvexInfo *pConvexInfo, const CPhysCollide *pSurface, const Vector &surfaceOrigin, const QAngle &surfaceAngles, trace_t *ptr );
+
+	// Calculate the intersection of a swept compact surface against another compact surface.  All coords are in HL space.
+	// NOTE: BUGBUG: swept surface must be single convex!!!
+	void 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 );
+
+	// get an AABB for an oriented collide
+	void GetAABB( Vector *pMins, Vector *pMaxs, const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles );
+
+	// get the support map/extent for a collide along the axis given by "direction"
+	Vector GetExtent( const CPhysCollide *pCollide, const Vector &collideOrigin, const QAngle &collideAngles, const Vector &direction );
+
+	bool IsBoxIntersectingCone( const Vector &boxAbsMins, const Vector &boxAbsMaxs, const truncatedcone_t &cone );
+};
+
+
+class CVisitHash
+{
+public:
+	CVisitHash();
+	inline unsigned short VertIndexToID( int vertIndex );
+	inline void VisitVert( int vertIndex );
+	inline bool WasVisited( int vertIndex );
+	inline void NewVisit( void );
+
+private:
+
+	// Store the current increment and the vertex ID (rotating hash) to guarantee no collisions
+	struct vertmarker_t
+	{
+		unsigned short visitID;
+		unsigned short vertID;
+	};
+
+	vertmarker_t		m_vertVisit[CONVEX_HASH_SIZE];
+	unsigned short		m_vertVisitID;
+	unsigned short		m_isInUse;
+};
+
+// Calculate the intersection of a swept box (mins/maxs) against an IVP object.  All coords are in HL space.
+inline unsigned short CVisitHash::VertIndexToID( int vertIndex )
+{
+	// A little hashing trick here:
+	// rotate the hash key each time you wrap around at 64K
+	// That way, the index will not collide until you've hit 64K # hash entries times
+	int high = vertIndex >> 16;
+	return (unsigned short) ((vertIndex + high) & 0xFFFF);
+}
+
+inline void CVisitHash::VisitVert( int vertIndex ) 
+{
+	int index = vertIndex & (CONVEX_HASH_SIZE-1);
+	m_vertVisit[index].visitID = m_vertVisitID;
+	m_vertVisit[index].vertID = VertIndexToID(vertIndex);
+}
+
+inline bool CVisitHash::WasVisited( int vertIndex ) 
+{
+	unsigned short hashIndex = vertIndex & (CONVEX_HASH_SIZE-1);
+	unsigned short id = VertIndexToID(vertIndex);
+	if ( m_vertVisit[hashIndex].visitID == m_vertVisitID && m_vertVisit[hashIndex].vertID == id )
+		return true;
+
+	return false;
+}
+
+inline void CVisitHash::NewVisit( void ) 
+{ 
+	m_vertVisitID++;
+	if ( m_vertVisitID == 0 )
+	{
+		memset( m_vertVisit, 0, sizeof(m_vertVisit) );
+	}
+
+}
+
+
+
+extern IVP_SurfaceManager *CreateSurfaceManager( const CPhysCollide *pCollisionModel, short &collideType );
+extern void OutputCollideDebugInfo( const CPhysCollide *pCollisionModel );
+
+#endif // PHYSICS_TRACE_H