added code for trace rays + natives

--HG--
extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401081

extensions/sdktools/extension.cpp

@@ -34,16 +34,19 @@
 
 SDKTools g_SdkTools;		/**< Global singleton for extension's main interface */
 IServerGameEnts *gameents = NULL;
+IEngineTrace *enginetrace = NULL;
 IBinTools *g_pBinTools = NULL;
 IGameConfig *g_pGameConf = NULL;
 IGameHelpers *g_pGameHelpers = NULL;
 IEngineSound *engsound = NULL;
 HandleType_t g_CallHandle = 0;
+HandleType_t g_TraceHandle = 0;
 
 SMEXT_LINK(&g_SdkTools);
 
 extern sp_nativeinfo_t g_CallNatives[];
 extern sp_nativeinfo_t g_TENatives[];
+extern sp_nativeinfo_t g_TRNatives[];
 
 bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late)
 {
@@ -52,6 +55,7 @@ bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late)
 	sharesys->AddNatives(myself, g_Natives);
 	sharesys->AddNatives(myself, g_TENatives);
 	sharesys->AddNatives(myself, g_SoundNatives);
+	sharesys->AddNatives(myself, g_TRNatives);
 
 	SM_GET_IFACE(GAMEHELPERS, g_pGameHelpers);
 
@@ -61,6 +65,7 @@ bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late)
 	}
 
 	g_CallHandle = handlesys->CreateType("ValveCall", this, 0, NULL, NULL, myself->GetIdentity(), NULL);
+	g_TraceHandle = handlesys->CreateType("TraceRay", this, 0, NULL, NULL, myself->GetIdentity(), NULL);
 
 	ConCommandBaseMgr::OneTimeInit(this);
 
@@ -74,6 +79,11 @@ void SDKTools::OnHandleDestroy(HandleType_t type, void *object)
 		ValveCall *v = (ValveCall *)object;
 		delete v;
 	}
+	if (type == g_TraceHandle)
+	{
+		trace_t *tr = (trace_t *)object;
+		delete tr;
+	}
 }
 
 void SDKTools::SDK_OnUnload()
@@ -96,6 +106,7 @@ bool SDKTools::SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlen, bool
 {
 	GET_V_IFACE_ANY(serverFactory, gameents, IServerGameEnts, INTERFACEVERSION_SERVERGAMEENTS);
 	GET_V_IFACE_ANY(engineFactory, engsound, IEngineSound, IENGINESOUND_SERVER_INTERFACE_VERSION);
+	GET_V_IFACE_ANY(engineFactory, enginetrace, IEngineTrace, INTERFACEVERSION_ENGINETRACE_SERVER);
 
 	return true;
 }

extensions/sdktools/extension.h

@@ -33,6 +33,7 @@
 #include <IBinTools.h>
 #include <IPlayerHelpers.h>
 #include <IGameHelpers.h>
+#include <IEngineTrace.h>
 #include <IEngineSound.h>
 #include <convar.h>
 
@@ -66,10 +67,12 @@ public: //IConCommandBaseAccessor
 };
 
 extern IServerGameEnts *gameents;
+extern IEngineTrace *enginetrace;
 extern IBinTools *g_pBinTools;
 extern IGameConfig *g_pGameConf;
 extern IGameHelpers *g_pGameHelpers;
-extern HandleType_t g_CallHandle;
 extern IEngineSound *engsound;
+extern HandleType_t g_CallHandle;
+extern HandleType_t g_TraceHandle;
 
 #endif //_INCLUDE_SOURCEMOD_EXTENSION_PROPER_H_

extensions/sdktools/msvc8/sdktools.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="Windows-1252"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8.00"
+	Version="8,00"
 	Name="sdktools"
 	ProjectGUID="{7A740927-C751-4312-BF9D-6367F8C508F8}"
 	RootNamespace="sdk"
@@ -62,7 +62,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="vstdlib.lib tier0.lib tier1.lib"
+				AdditionalDependencies="vstdlib.lib tier0.lib tier1.lib mathlib.lib"
 				OutputFile="$(OutDir)\sdktools.ext.dll"
 				LinkIncremental="2"
 				IgnoreDefaultLibraryNames="LIBCMT"
@@ -140,7 +140,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="vstdlib.lib tier0.lib tier1.lib"
+				AdditionalDependencies="vstdlib.lib tier0.lib tier1.lib mathlib.lib"
 				OutputFile="$(OutDir)\sdktools.ext.dll"
 				LinkIncremental="1"
 				GenerateDebugInformation="true"
@@ -199,6 +199,10 @@
 				RelativePath="..\tenatives.cpp"
 				>
 			</File>
+			<File
+				RelativePath="..\trnatives.cpp"
+				>
+			</File>
 			<File
 				RelativePath="..\vcallbuilder.cpp"
 				>

extensions/sdktools/tempents.cpp

@@ -125,7 +125,7 @@ bool TempEntityInfo::TE_SetEntData(const char *name, int value)
 		*((uint8_t *)m_Me + offset) = value;
 	} else if (size <= 16) {
 		*(short *)((uint8_t *)m_Me + offset) = value;
-	} else if (size <= 32){
+	} else if (size <= 32) {
 		*(int *)((uint8_t *)m_Me + offset) = value;
 	} else {
 		return false;

extensions/sdktools/trnatives.cpp

@@ -0,0 +1,386 @@
+/**
+ * vim: set ts=4 :
+ * ===============================================================
+ * SourceMod SDK Tools Extension
+ * Copyright (C) 2004-2007 AlliedModders LLC. All rights reserved.
+ * ===============================================================
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Version: $Id$
+ */
+
+#include "extension.h"
+#include <worldsize.h>
+
+class CSMTraceFilter : public CTraceFilter
+{
+public:
+	bool ShouldHitEntity(IHandleEntity *pEntity, int contentsMask)
+	{
+		cell_t res = 1;
+		edict_t *pEdict = gameents->BaseEntityToEdict(reinterpret_cast<CBaseEntity *>(pEntity));
+		m_pFunc->PushCell(engine->IndexOfEdict(pEdict));
+		m_pFunc->PushCell(contentsMask);
+		m_pFunc->Execute(&res);
+
+		return (res) ? true : false;
+	}
+	void SetFunctionPtr(IPluginFunction *pFunc)
+	{
+		m_pFunc = pFunc;
+	}
+private:
+	IPluginFunction *m_pFunc;
+};
+
+/* Used for the global trace version */
+Ray_t g_Ray;
+trace_t g_Trace;
+Vector g_StartVec;
+Vector g_EndVec;
+QAngle g_DirAngles;
+CTraceFilterHitAll g_HitAllFilter;
+CSMTraceFilter g_SMTraceFilter;
+
+enum
+{
+	RayType_EndPoint,
+	RayType_Infinite
+};
+
+static cell_t smn_TRTraceRay(IPluginContext *pContext, const cell_t *params)
+{
+	cell_t *startaddr, *endaddr;
+	pContext->LocalToPhysAddr(params[1], &startaddr);
+	pContext->LocalToPhysAddr(params[2], &endaddr);
+
+	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));
+
+	switch (params[4])
+	{
+	case RayType_EndPoint:
+		{
+			g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			break;
+		}
+	case RayType_Infinite:
+		{
+			g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			AngleVectors(g_DirAngles, &g_EndVec);
+
+			/* Make it unitary and get the ending point */
+			g_EndVec.NormalizeInPlace();
+			g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH;
+			break;
+		}
+	}
+
+	g_Ray.Init(g_StartVec, g_EndVec);
+	enginetrace->TraceRay(g_Ray, params[3], &g_HitAllFilter, &g_Trace);
+
+	return 1;
+}
+
+static cell_t smn_TRTraceRayFilter(IPluginContext *pContext, const cell_t *params)
+{
+	cell_t *startaddr, *endaddr;
+	IPluginFunction *pFunc;
+
+	pFunc = pContext->GetFunctionById(params[5]);
+	if (!pFunc)
+	{
+		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);
+	}
+	g_SMTraceFilter.SetFunctionPtr(pFunc);
+	pContext->LocalToPhysAddr(params[1], &startaddr);
+	pContext->LocalToPhysAddr(params[2], &endaddr);
+
+	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));
+
+	switch (params[4])
+	{
+	case RayType_EndPoint:
+		{
+			g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			break;
+		}
+	case RayType_Infinite:
+		{
+			g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			AngleVectors(g_DirAngles, &g_EndVec);
+
+			/* Make it unitary and get the ending point */
+			g_EndVec.NormalizeInPlace();
+			g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH;
+			break;
+		}
+	}
+
+	g_Ray.Init(g_StartVec, g_EndVec);
+	enginetrace->TraceRay(g_Ray, params[3], &g_SMTraceFilter, &g_Trace);
+
+	return 1;
+}
+
+static cell_t smn_TRTraceRayEx(IPluginContext *pContext, const cell_t *params)
+{
+	cell_t *startaddr, *endaddr;
+	pContext->LocalToPhysAddr(params[1], &startaddr);
+	pContext->LocalToPhysAddr(params[2], &endaddr);
+
+	Vector StartVec, EndVec;
+	Ray_t ray;
+
+	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));
+
+	switch (params[4])
+	{
+	case RayType_EndPoint:
+		{
+			EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			break;
+		}
+	case RayType_Infinite:
+		{
+			QAngle DirAngles;
+			DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			AngleVectors(DirAngles, &EndVec);
+
+			/* Make it unitary and get the ending point */
+			EndVec.NormalizeInPlace();
+			EndVec = StartVec + EndVec * MAX_TRACE_LENGTH;
+			break;
+		}
+	}
+
+	trace_t *tr = new trace_t;
+	ray.Init(StartVec, EndVec);
+	enginetrace->TraceRay(ray, params[3], &g_HitAllFilter, tr);
+
+	HandleError herr;
+	Handle_t hndl;
+	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))
+	{
+		delete tr;
+		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);
+	}
+
+	return hndl;
+}
+
+static cell_t smn_TRTraceRayFilterEx(IPluginContext *pContext, const cell_t *params)
+{
+	IPluginFunction *pFunc;
+	cell_t *startaddr, *endaddr;
+
+	pFunc = pContext->GetFunctionById(params[5]);
+	if (!pFunc)
+	{
+		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);
+	}
+	pContext->LocalToPhysAddr(params[1], &startaddr);
+	pContext->LocalToPhysAddr(params[2], &endaddr);
+
+	Vector StartVec, EndVec;
+	CSMTraceFilter smfilter;
+	Ray_t ray;
+
+	smfilter.SetFunctionPtr(pFunc);
+	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));
+
+	switch (params[4])
+	{
+	case RayType_EndPoint:
+		{
+			EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			break;
+		}
+	case RayType_Infinite:
+		{
+			QAngle DirAngles;
+			DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));
+			AngleVectors(DirAngles, &EndVec);
+
+			/* Make it unitary and get the ending point */
+			EndVec.NormalizeInPlace();
+			EndVec = StartVec + EndVec * MAX_TRACE_LENGTH;
+			break;
+		}
+	}
+
+	trace_t *tr = new trace_t;
+	ray.Init(StartVec, EndVec);
+	enginetrace->TraceRay(ray, params[3], &smfilter, tr);
+
+	HandleError herr;
+	Handle_t hndl;
+	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))
+	{
+		delete tr;
+		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);
+	}
+
+	return hndl;
+}
+
+static cell_t smn_TRGetFraction(IPluginContext *pContext, const cell_t *params)
+{
+	trace_t *tr;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
+
+	if (params[1] == BAD_HANDLE)
+	{
+		tr = &g_Trace;
+	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
+	}
+
+	return sp_ftoc(tr->fraction);
+}
+
+static cell_t smn_TRGetEndPosition(IPluginContext *pContext, const cell_t *params)
+{
+	trace_t *tr;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
+
+	if (params[2] == BAD_HANDLE)
+	{
+		tr = &g_Trace;
+	} else if ((err = handlesys->ReadHandle(params[2], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);
+	}
+
+	cell_t *addr;
+	pContext->LocalToPhysAddr(params[1], &addr);
+
+	addr[0] = sp_ftoc(tr->endpos.x);
+	addr[1] = sp_ftoc(tr->endpos.y);
+	addr[2] = sp_ftoc(tr->endpos.z);
+
+	return 1;
+}
+
+static cell_t smn_TRDidHit(IPluginContext *pContext, const cell_t *params)
+{
+	trace_t *tr;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
+
+	if (params[1] == BAD_HANDLE)
+	{
+		tr = &g_Trace;
+	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
+	}
+
+	return tr->DidHit() ? 1 : 0;
+}
+
+static cell_t smn_TRGetHitGroup(IPluginContext *pContext, const cell_t *params)
+{
+	trace_t *tr;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
+
+	if (params[1] == BAD_HANDLE)
+	{
+		tr = &g_Trace;
+	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
+	}
+
+	return tr->hitgroup;
+}
+
+static cell_t smn_TRGetEntityIndex(IPluginContext *pContext, const cell_t *params)
+{
+	trace_t *tr;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
+
+	if (params[1] == BAD_HANDLE)
+	{
+		tr = &g_Trace;
+	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
+	}
+
+	edict_t *pEdict = gameents->BaseEntityToEdict(tr->m_pEnt);
+	return engine->IndexOfEdict(pEdict);
+}
+
+static cell_t smn_TRGetPointContents(IPluginContext *pContext, const cell_t *params)
+{
+	cell_t *vec, *ent;
+	IHandleEntity *hentity;
+	Vector pos;
+	int mask;
+
+	pContext->LocalToPhysAddr(params[1], &vec);
+	pContext->LocalToPhysAddr(params[2], &ent);
+
+	pos.x = sp_ctof(vec[0]);
+	pos.y = sp_ctof(vec[1]);
+	pos.z = sp_ctof(vec[2]);
+
+	if (*ent == -1)
+	{
+		mask = enginetrace->GetPointContents(pos);
+	} else {
+		mask = enginetrace->GetPointContents(pos, &hentity);
+		edict_t *pEdict = gameents->BaseEntityToEdict(reinterpret_cast<CBaseEntity *>(hentity));
+		*ent = engine->IndexOfEdict(pEdict);
+	}
+
+	return mask;
+}
+
+static cell_t smn_TRGetPointContentsEnt(IPluginContext *pContext, const cell_t *params)
+{
+	edict_t *pEdict = engine->PEntityOfEntIndex(params[1]);
+	if (!pEdict || pEdict->IsFree())
+	{
+		return pContext->ThrowNativeError("Entity %d is invalid", params[1]);
+	}
+
+	cell_t *addr;
+	Vector pos;
+
+	pContext->LocalToPhysAddr(params[2], &addr);
+
+	pos.x = sp_ctof(addr[0]);
+	pos.y = sp_ctof(addr[1]);
+	pos.z = sp_ctof(addr[2]);
+
+	return enginetrace->GetPointContents_Collideable(pEdict->GetCollideable(), pos);
+}
+
+sp_nativeinfo_t g_TRNatives[] = 
+{
+	{"TR_TraceRay",				smn_TRTraceRay},
+	{"TR_TraceRayEx",			smn_TRTraceRayEx},
+	{"TR_GetFraction",			smn_TRGetFraction},
+	{"TR_GetEndPosition",		smn_TRGetEndPosition},
+	{"TR_GetEntityIndex",		smn_TRGetEntityIndex},
+	{"TR_DidHit",				smn_TRDidHit},
+	{"TR_GetHitGroup",			smn_TRGetHitGroup},
+	{"TR_GetPointContents",		smn_TRGetPointContents},
+	{"TR_GetPointContentsEnt",	smn_TRGetPointContentsEnt},
+	{"TR_TraceRayFilter",		smn_TRTraceRayFilter},
+	{"TR_TraceRayFilterEx",		smn_TRTraceRayFilterEx},
+	{NULL,						NULL}
+};

plugins/include/sdktools.inc

@@ -25,6 +25,7 @@
 #if !defined SDKTOOLS_DISABLE_SOUNDAPI
 #include <sdktools_sound>
 #endif
+#include <sdktools_trace>
 
 enum SDKCallType
 {

plugins/include/sdktools_trace.inc

@@ -0,0 +1,215 @@
+/**
+ * vim: set ts=4 :
+ * ===============================================================
+ * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.
+ * ===============================================================
+ *
+ *  This file is part of the SourceMod/SourcePawn SDK.  This file may only be used 
+ * or modified under the Terms and Conditions of its License Agreement, which is found 
+ * in LICENSE.txt.  The Terms and Conditions for making SourceMod extensions/plugins 
+ * may change at any time.  To view the latest information, see:
+ *   http://www.sourcemod.net/license.php
+ *
+ * Version: $Id$
+ */
+
+#if defined _sdktools_trace_included
+ #endinput
+#endif
+#define _sdktools_trace_included
+
+#define	CONTENTS_EMPTY			0		/**< No contents. */
+#define	CONTENTS_SOLID			0x1		/**< an eye is never valid in a solid . */
+#define	CONTENTS_WINDOW			0x2		/**< translucent, but not watery (glass). */
+#define	CONTENTS_AUX			0x4
+#define	CONTENTS_GRATE			0x8		/**< alpha-tested "grate" textures.  Bullets/sight pass through, but solids don't. */
+#define	CONTENTS_SLIME			0x10
+#define	CONTENTS_WATER			0x20
+#define	CONTENTS_MIST			0x40
+#define CONTENTS_OPAQUE			0x80		/**< things that cannot be seen through (may be non-solid though). */
+#define	LAST_VISIBLE_CONTENTS		0x80
+#define ALL_VISIBLE_CONTENTS 		(LAST_VISIBLE_CONTENTS | (LAST_VISIBLE_CONTENTS-1))
+#define CONTENTS_TESTFOGVOLUME		0x100
+#define CONTENTS_UNUSED5		0x200
+#define CONTENTS_UNUSED6		0x4000
+#define CONTENTS_TEAM1			0x800		/**< per team contents used to differentiate collisions. */
+#define CONTENTS_TEAM2			0x1000		/**< between players and objects on different teams. */
+#define CONTENTS_IGNORE_NODRAW_OPAQUE	0x2000		/**< ignore CONTENTS_OPAQUE on surfaces that have SURF_NODRAW. */
+#define CONTENTS_MOVEABLE		0x4000		/**< hits entities which are MOVETYPE_PUSH (doors, plats, etc) */
+#define	CONTENTS_AREAPORTAL		0x8000		/**< remaining contents are non-visible, and don't eat brushes. */
+#define	CONTENTS_PLAYERCLIP		0x10000
+#define	CONTENTS_MONSTERCLIP		0x20000
+
+/**
+ * @section currents can be added to any other contents, and may be mixed
+ */
+#define	CONTENTS_CURRENT_0		0x40000
+#define	CONTENTS_CURRENT_90		0x80000
+#define	CONTENTS_CURRENT_180		0x100000
+#define	CONTENTS_CURRENT_270		0x200000
+#define	CONTENTS_CURRENT_UP		0x400000
+#define	CONTENTS_CURRENT_DOWN		0x800000
+
+/**
+ * @endsection
+ */
+
+#define	CONTENTS_ORIGIN			0x1000000	/**< removed before bsping an entity. */
+#define	CONTENTS_MONSTER		0x2000000	/**< should never be on a brush, only in game. */
+#define	CONTENTS_DEBRIS			0x4000000
+#define	CONTENTS_DETAIL			0x8000000	/**< brushes to be added after vis leafs. */
+#define	CONTENTS_TRANSLUCENT		0x10000000	/**< auto set if any surface has trans. */
+#define	CONTENTS_LADDER			0x20000000
+#define CONTENTS_HITBOX			0x40000000	/**< use accurate hitboxes on trace. */
+
+/**
+ * @section Trace masks.
+ */
+#define	MASK_ALL			(0xFFFFFFFF)
+#define	MASK_SOLID			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) 			/**< everything that is normally solid */
+#define	MASK_PLAYERSOLID		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_PLAYERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) 	/**< everything that blocks player movement */
+#define	MASK_NPCSOLID			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTERCLIP|CONTENTS_WINDOW|CONTENTS_MONSTER|CONTENTS_GRATE) /**< blocks npc movement */
+#define	MASK_WATER			(CONTENTS_WATER|CONTENTS_MOVEABLE|CONTENTS_SLIME) 							/**< water physics in these contents */
+#define	MASK_OPAQUE			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_OPAQUE) 							/**< everything that blocks line of sight for AI, lighting, etc */
+#define MASK_OPAQUE_AND_NPCS		(MASK_OPAQUE|CONTENTS_MONSTER)										/**< everything that blocks line of sight for AI, lighting, etc, but with monsters added. */
+#define	MASK_VISIBLE			(MASK_OPAQUE|CONTENTS_IGNORE_NODRAW_OPAQUE) 								/**< everything that blocks line of sight for players */
+#define MASK_VISIBLE_AND_NPCS		(MASK_OPAQUE_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE) 							/**< everything that blocks line of sight for players, but with monsters added. */
+#define	MASK_SHOT			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_HITBOX) 	/**< bullets see these as solid */
+#define MASK_SHOT_HULL			(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_MONSTER|CONTENTS_WINDOW|CONTENTS_DEBRIS|CONTENTS_GRATE) 	/**< non-raycasted weapons see this as solid (includes grates) */
+#define MASK_SHOT_PORTAL		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW) 							/**< hits solids (not grates) and passes through everything else */
+#define MASK_SOLID_BRUSHONLY		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_GRATE) 					/**< everything normally solid, except monsters (world+brush only) */
+#define MASK_PLAYERSOLID_BRUSHONLY	(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_PLAYERCLIP|CONTENTS_GRATE) 			/**< everything normally solid for player movement, except monsters (world+brush only) */
+#define MASK_NPCSOLID_BRUSHONLY		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) 			/**< everything normally solid for npc movement, except monsters (world+brush only) */
+#define MASK_NPCWORLDSTATIC		(CONTENTS_SOLID|CONTENTS_WINDOW|CONTENTS_MONSTERCLIP|CONTENTS_GRATE) 					/**< just the world, used for route rebuilding */
+#define MASK_SPLITAREAPORTAL		(CONTENTS_WATER|CONTENTS_SLIME) 									/**< These are things that can split areaportals */
+
+/**
+ * @endsection
+ */
+
+enum RayType
+{
+	RayType_EndPoint,	/**< The trace ray will go from the start position to the end position. */
+	RayType_Infinite	/**< The trace ray will go from the start position to infinity using a direction vector. */
+};
+
+/**
+ * Called on entity filtering.
+ *
+ * @param entity		Entity index.
+ * @param contentsMask		Contents Mask.
+ * @return			True to allow the current entity to be hit, otherwise false.
+ */
+functag TraceEntityFilter bool:public(entity, contentsMask);
+
+/**
+ * Get the contents mask and the entity index at the given position.
+ *
+ * @param pos			World position to test.
+ * @param entindex		Entity index found at the given position (by reference).
+ * @return			Contents mask.
+ */
+native TR_GetPointContents(const Float:pos[3], &entindex=-1);
+
+/**
+ * Get the point contents testing only the given entity index.
+ *
+ * @param entindex		Entity index to test.
+ * @param pos			World position.
+ * @return			Contents mask.
+ */
+native TR_GetPointContentsEnt(entindex, const Float:pos[3]);
+
+/**
+ * Starts up a new trace ray using a global trace result.
+ *
+ * @param pos			Starting position of the ray.
+ * @param vec			Depending on RayType, it will be used as the ending point, or the direction angle.
+ * @param flags			Trace flags.
+ * @param rtype			Method to calculate the ray direction.
+ * @noreturn
+ */
+native TR_TraceRay(const Float:pos[3], const Float:vec[3], flags, RayType:rtype);
+
+/**
+ * Starts up a new trace ray using a global trace result and a customized trace ray filter.
+ *
+ * @param pos			Starting position of the ray.
+ * @param vec			Depending on RayType, it will be used as the ending point, or the direction angle.
+ * @param flags			Trace flags.
+ * @param rtype			Method to calculate the ray direction.
+ * @param filter		Function to use as a filter.
+ * @noreturn
+ */
+native TR_TraceRayFilter(const Float:pos[3], const Float:vec[3], flags, RayType:rtype, TraceEntityFilter:filter);
+
+/**
+ * Starts up a new trace ray using a new trace result.
+ *
+ * @param pos			Starting position of the ray.
+ * @param vec			Depending on RayType, it will be used as the ending point, or the direction angle.
+ * @param flags			Trace flags.
+ * @param rtype			Method to calculate the ray direction.
+ * @return			Ray trace handle.
+ * @note Traces are closed with CloseHandle().
+ */
+native Handle:TR_TraceRayEx(const Float:pos[3], const Float:vec[3], flags, RayType:rtype);
+
+/**
+ * Starts up a new trace ray using a new trace result and a customized trace ray filter.
+ *
+ * @param pos			Starting position of the ray.
+ * @param vec			Depending on RayType, it will be used as the ending point, or the direction angle.
+ * @param flags			Trace flags.
+ * @param rtype			Method to calculate the ray direction.
+ * @param filter		Function to use as a filter.
+ * @return			Ray trace handle.
+ * @note Traces are closed with CloseHandle().
+ */
+native Handle:TR_TraceRayFilterEx(const Float:pos[3], const Float:vec[3], flags, RayType:rtype, TraceEntityFilter:filter);
+
+/**
+ * Returns the time fraction from a trace result (1.0 means no collision).
+ *
+ * @param hndl			A trace Handle, or INVALID_HANDLE to use a global trace result.
+ * @return			Time fraction value of the trace.
+ * @error			Invalid Handle.
+ */
+native Float:TR_GetFraction(Handle:hndl=INVALID_HANDLE);
+
+/**
+ * Returns the collision position of a trace result.
+ *
+ * @param pos			Vector buffer to store data in.
+ * @param hndl			A trace Handle, or INVALID_HANDLE to use a global trace result.
+ * @noreturn
+ * @error			Invalid Handle.
+ */
+native TR_GetEndPosition(Float:pos[3], Handle:hndl=INVALID_HANDLE);
+
+/**
+ * Returns the entity index that collided with the trace.
+ *
+ * @param hndl			A trace Handle, or INVALID_HANDLE to use a global trace result.
+ * @return			Entity index or -1 for no collision.
+ * @error			Invalid Handle.
+ */
+native TR_GetEntityIndex(Handle:hndl=INVALID_HANDLE);
+
+/**
+ * Returns if there was any kind of collision along the trace ray.
+ *
+ * @param hndl			A trace Handle, or INVALID_HANDLE to use a global trace result.
+ * @return			True if any collision found, otherwise false.
+ * @error			Invalid Handle.
+ */
+native bool:TR_DidHit(Handle:hndl=INVALID_HANDLE);
+
+/**
+ * Returns in which body hit group the trace collided if any.
+ *
+ * @param hndl			A trace Handle, or INVALID_HANDLE to use a global trace result.
+ * @return			Body hit group.
+ * @error			Invalid Handle.
+ */
+native TR_GetHitGroup(Handle:hndl=INVALID_HANDLE);