1 files changed, 192 insertions, 0 deletions
diff --git a/public/engine/IEngineTrace.h b/public/engine/IEngineTrace.h
new file mode 100644
index 0000000..6e49771
--- /dev/null
+++ b/public/engine/IEngineTrace.h
@@ -0,0 +1,192 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#ifndef ENGINE_IENGINETRACE_H
+#define ENGINE_IENGINETRACE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basehandle.h"
+#include "utlvector.h" //need CUtlVector for IEngineTrace::GetBrushesIn*()
+#include "mathlib/vector4d.h"
+
+class Vector;
+class IHandleEntity;
+struct Ray_t;
+class CGameTrace;
+typedef CGameTrace trace_t;
+class ICollideable;
+class QAngle;
+class CTraceListData;
+class CPhysCollide;
+struct cplane_t;
+
+//-----------------------------------------------------------------------------
+// The standard trace filter... NOTE: Most normal traces inherit from CTraceFilter!!!
+//-----------------------------------------------------------------------------
+enum TraceType_t
+{
+	TRACE_EVERYTHING = 0,
+	TRACE_WORLD_ONLY,				// NOTE: This does *not* test static props!!!
+	TRACE_ENTITIES_ONLY,			// NOTE: This version will *not* test static props
+	TRACE_EVERYTHING_FILTER_PROPS,	// NOTE: This version will pass the IHandleEntity for props through the filter, unlike all other filters
+};
+
+abstract_class ITraceFilter
+{
+public:
+	virtual bool ShouldHitEntity( IHandleEntity *pEntity, int contentsMask ) = 0;
+	virtual TraceType_t	GetTraceType() const = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Classes are expected to inherit these + implement the ShouldHitEntity method
+//-----------------------------------------------------------------------------
+
+// This is the one most normal traces will inherit from
+class CTraceFilter : public ITraceFilter
+{
+public:
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_EVERYTHING;
+	}
+};
+
+class CTraceFilterEntitiesOnly : public ITraceFilter
+{
+public:
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_ENTITIES_ONLY;
+	}
+};
+
+
+//-----------------------------------------------------------------------------
+// Classes need not inherit from these
+//-----------------------------------------------------------------------------
+class CTraceFilterWorldOnly : public ITraceFilter
+{
+public:
+	bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		return false;
+	}
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_WORLD_ONLY;
+	}
+};
+
+class CTraceFilterWorldAndPropsOnly : public ITraceFilter
+{
+public:
+	bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		return false;
+	}
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_EVERYTHING;
+	}
+};
+
+class CTraceFilterHitAll : public CTraceFilter
+{
+public:
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{ 
+		return true; 
+	}
+};
+
+
+//-----------------------------------------------------------------------------
+// Enumeration interface for EnumerateLinkEntities
+//-----------------------------------------------------------------------------
+abstract_class IEntityEnumerator
+{
+public:
+	// This gets called with each handle
+	virtual bool EnumEntity( IHandleEntity *pHandleEntity ) = 0; 
+};
+
+
+//-----------------------------------------------------------------------------
+// Interface the engine exposes to the game DLL
+//-----------------------------------------------------------------------------
+#define INTERFACEVERSION_ENGINETRACE_SERVER	"EngineTraceServer003"
+#define INTERFACEVERSION_ENGINETRACE_CLIENT	"EngineTraceClient003"
+abstract_class IEngineTrace
+{
+public:
+	// Returns the contents mask + entity at a particular world-space position
+	virtual int		GetPointContents( const Vector &vecAbsPosition, IHandleEntity** ppEntity = NULL ) = 0;
+	
+	// Get the point contents, but only test the specific entity. This works
+	// on static props and brush models.
+	//
+	// If the entity isn't a static prop or a brush model, it returns CONTENTS_EMPTY and sets
+	// bFailed to true if bFailed is non-null.
+	virtual int		GetPointContents_Collideable( ICollideable *pCollide, const Vector &vecAbsPosition ) = 0;
+
+	// Traces a ray against a particular entity
+	virtual void	ClipRayToEntity( const Ray_t &ray, unsigned int fMask, IHandleEntity *pEnt, trace_t *pTrace ) = 0;
+
+	// Traces a ray against a particular entity
+	virtual void	ClipRayToCollideable( const Ray_t &ray, unsigned int fMask, ICollideable *pCollide, trace_t *pTrace ) = 0;
+
+	// A version that simply accepts a ray (can work as a traceline or tracehull)
+	virtual void	TraceRay( const Ray_t &ray, unsigned int fMask, ITraceFilter *pTraceFilter, trace_t *pTrace ) = 0;
+
+	// A version that sets up the leaf and entity lists and allows you to pass those in for collision.
+	virtual void	SetupLeafAndEntityListRay( const Ray_t &ray, CTraceListData &traceData ) = 0;
+	virtual void    SetupLeafAndEntityListBox( const Vector &vecBoxMin, const Vector &vecBoxMax, CTraceListData &traceData ) = 0;
+	virtual void	TraceRayAgainstLeafAndEntityList( const Ray_t &ray, CTraceListData &traceData, unsigned int fMask, ITraceFilter *pTraceFilter, trace_t *pTrace ) = 0;
+
+	// A version that sweeps a collideable through the world
+	// abs start + abs end represents the collision origins you want to sweep the collideable through
+	// vecAngles represents the collision angles of the collideable during the sweep
+	virtual void	SweepCollideable( ICollideable *pCollide, const Vector &vecAbsStart, const Vector &vecAbsEnd, 
+		const QAngle &vecAngles, unsigned int fMask, ITraceFilter *pTraceFilter, trace_t *pTrace ) = 0;
+
+	// Enumerates over all entities along a ray
+	// If triggers == true, it enumerates all triggers along a ray
+	virtual void	EnumerateEntities( const Ray_t &ray, bool triggers, IEntityEnumerator *pEnumerator ) = 0;
+
+	// Same thing, but enumerate entitys within a box
+	virtual void	EnumerateEntities( const Vector &vecAbsMins, const Vector &vecAbsMaxs, IEntityEnumerator *pEnumerator ) = 0;
+
+	// Convert a handle entity to a collideable.  Useful inside enumer
+	virtual ICollideable *GetCollideable( IHandleEntity *pEntity ) = 0;
+
+	// HACKHACK: Temp for performance measurments
+	virtual int GetStatByIndex( int index, bool bClear ) = 0;
+
+
+	//finds brushes in an AABB, prone to some false positives
+	virtual void GetBrushesInAABB( const Vector &vMins, const Vector &vMaxs, CUtlVector<int> *pOutput, int iContentsMask = 0xFFFFFFFF ) = 0;
+
+	//Creates a CPhysCollide out of all displacements wholly or partially contained in the specified AABB
+	virtual CPhysCollide* GetCollidableFromDisplacementsInAABB( const Vector& vMins, const Vector& vMaxs ) = 0;
+
+	//retrieve brush planes and contents, returns true if data is being returned in the output pointers, false if the brush doesn't exist
+	virtual bool GetBrushInfo( int iBrush, CUtlVector<Vector4D> *pPlanesOut, int *pContentsOut ) = 0;
+
+	virtual bool PointOutsideWorld( const Vector &ptTest ) = 0; //Tests a point to see if it's outside any playable area
+
+	// Walks bsp to find the leaf containing the specified point
+	virtual int GetLeafContainingPoint( const Vector &ptTest ) = 0;
+};
+
+
+
+#endif // ENGINE_IENGINETRACE_H