be_aas_sample.c File Reference

#include "../game/q_shared.h"
#include "l_memory.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "l_libvar.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_interface.h"
#include "be_aas_funcs.h"
#include "be_aas_def.h"

Include dependency graph for be_aas_sample.c:

Go to the source code of this file.

Data Structures
struct	aas_linkstack_t
struct	aas_tracestack_s
Defines
#define	AAS_BoxOnPlaneSide(absmins, absmaxs, p)
#define	AAS_OrthogonalToVectors(v1, v2, res)
#define	BBOX_NORMAL_EPSILON   0.001
#define	ON_EPSILON   0
#define	TRACEPLANE_EPSILON   0.125
Typedefs
typedef aas_tracestack_s	aas_tracestack_t
Functions
aas_link_t *	AAS_AASLinkEntity (vec3_t absmins, vec3_t absmaxs, int entnum)
aas_link_t *	AAS_AllocAASLink (void)
int	AAS_AreaCluster (int areanum)
qboolean	AAS_AreaEntityCollision (int areanum, vec3_t start, vec3_t end, int presencetype, int passent, aas_trace_t *trace)
aas_face_t *	AAS_AreaGroundFace (int areanum, vec3_t point)
int	AAS_AreaInfo (int areanum, aas_areainfo_t *info)
int	AAS_AreaPresenceType (int areanum)
int	AAS_BBoxAreas (vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas)
int	AAS_BoxOnPlaneSide2 (vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
vec_t	AAS_BoxOriginDistanceFromPlane (vec3_t normal, vec3_t mins, vec3_t maxs, int side)
void	AAS_DeAllocAASLink (aas_link_t *link)
void	AAS_FacePlane (int facenum, vec3_t normal, float *dist)
void	AAS_FreeAASLinkedEntities (void)
void	AAS_FreeAASLinkHeap (void)
void	AAS_InitAASLinkedEntities (void)
void	AAS_InitAASLinkHeap (void)
qboolean	AAS_InsideFace (aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon)
aas_link_t *	AAS_LinkEntityClientBBox (vec3_t absmins, vec3_t absmaxs, int entnum, int presencetype)
aas_plane_t *	AAS_PlaneFromNum (int planenum)
int	AAS_PointAreaNum (vec3_t point)
qboolean	AAS_PointInsideFace (int facenum, vec3_t point, float epsilon)
int	AAS_PointPresenceType (vec3_t point)
int	AAS_PointReachabilityAreaIndex (vec3_t origin)
void	AAS_PresenceTypeBoundingBox (int presencetype, vec3_t mins, vec3_t maxs)
int	AAS_TraceAreas (vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
aas_trace_t	AAS_TraceClientBBox (vec3_t start, vec3_t end, int presencetype, int passent)
aas_face_t *	AAS_TraceEndFace (aas_trace_t *trace)
void	AAS_UnlinkFromAreas (aas_link_t *areas)
Variables
botlib_import_t	botimport
int	numaaslinks

---

Define Documentation

#define AAS_BoxOnPlaneSide (  absmins, absmaxs, p   )

Value: (\ ( (p)->type < 3) ?\ (\ ( (p)->dist <= (absmins)[(p)->type]) ?\ (\ 1\ )\ :\ (\ ( (p)->dist >= (absmaxs)[(p)->type]) ?\ (\ 2\ )\ :\ (\ 3\ )\ )\ )\ :\ (\ AAS_BoxOnPlaneSide2((absmins), (absmaxs), (p))\ )\ ) Definition at line 1161 of file be_aas_sample.c.

#define AAS_OrthogonalToVectors (  v1, v2, res   )

Value: (res)[0] = ((v1)[1] * (v2)[2]) - ((v1)[2] * (v2)[1]);\ (res)[1] = ((v1)[2] * (v2)[0]) - ((v1)[0] * (v2)[2]);\ (res)[2] = ((v1)[0] * (v2)[1]) - ((v1)[1] * (v2)[0]); Definition at line 913 of file be_aas_sample.c. Referenced by AAS_InsideFace().

#define BBOX_NORMAL_EPSILON   0.001

Definition at line 51 of file be_aas_sample.c.

#define ON_EPSILON   0

Definition at line 53 of file be_aas_sample.c.

#define TRACEPLANE_EPSILON   0.125

Definition at line 55 of file be_aas_sample.c.

---

Typedef Documentation

typedef struct aas_tracestack_s aas_tracestack_t

Referenced by AAS_TraceAreas(), and AAS_TraceClientBBox().

---

Function Documentation

aas_link_t* AAS_AASLinkEntity (  vec3_t  absmins, vec3_t  absmaxs, int  entnum )

Definition at line 1223 of file be_aas_sample.c. References AAS_AllocAASLink(), AAS_BoxOnPlaneSide2(), aas_link_t, aas_node_t, aas_plane_t, aasworld, aas_s::arealinkedentities, aas_link_s::areanum, botimport, aas_node_s::children, aas_link_s::entnum, aas_s::loaded, aas_link_s::next_area, aas_link_s::next_ent, aas_linkstack_t::nodenum, aas_s::nodes, aas_node_s::planenum, aas_s::planes, aas_link_s::prev_area, aas_link_s::prev_ent, and PRT_ERROR. Referenced by AAS_BBoxAreas(), and AAS_LinkEntityClientBBox(). { int side, nodenum; aas_linkstack_t linkstack[128]; aas_linkstack_t *lstack_p; aas_node_t *aasnode; aas_plane_t *plane; aas_link_t *link, *areas; if (!aasworld.loaded) { botimport.Print(PRT_ERROR, "AAS_LinkEntity: aas not loaded\n"); return NULL; } //end if areas = NULL; // lstack_p = linkstack; //we start with the whole line on the stack //start with node 1 because node zero is a dummy used for solid leafs lstack_p->nodenum = 1; //starting at the root of the tree lstack_p++; while (1) { //pop up the stack lstack_p--; //if the trace stack is empty (ended up with a piece of the //line to be traced in an area) if (lstack_p < linkstack) break; //number of the current node to test the line against nodenum = lstack_p->nodenum; //if it is an area if (nodenum < 0) { //NOTE: the entity might have already been linked into this area // because several node children can point to the same area for (link = aasworld.arealinkedentities[-nodenum]; link; link = link->next_ent) { if (link->entnum == entnum) break; } //end for if (link) continue; // link = AAS_AllocAASLink(); if (!link) return areas; link->entnum = entnum; link->areanum = -nodenum; //put the link into the double linked area list of the entity link->prev_area = NULL; link->next_area = areas; if (areas) areas->prev_area = link; areas = link; //put the link into the double linked entity list of the area link->prev_ent = NULL; link->next_ent = aasworld.arealinkedentities[-nodenum]; if (aasworld.arealinkedentities[-nodenum]) aasworld.arealinkedentities[-nodenum]->prev_ent = link; aasworld.arealinkedentities[-nodenum] = link; // continue; } //end if //if solid leaf if (!nodenum) continue; //the node to test against aasnode = &aasworld.nodes[nodenum]; //the current node plane plane = &aasworld.planes[aasnode->planenum]; //get the side(s) the box is situated relative to the plane side = AAS_BoxOnPlaneSide2(absmins, absmaxs, plane); //if on the front side of the node if (side & 1) { lstack_p->nodenum = aasnode->children[0]; lstack_p++; } //end if if (lstack_p >= &linkstack[127]) { botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n"); break; } //end if //if on the back side of the node if (side & 2) { lstack_p->nodenum = aasnode->children[1]; lstack_p++; } //end if if (lstack_p >= &linkstack[127]) { botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n"); break; } //end if } //end while return areas; } //end of the function AAS_AASLinkEntity

Here is the call graph for this function:

aas_link_t* AAS_AllocAASLink (  void   )

Definition at line 146 of file be_aas_sample.c. References aas_link_t, aasworld, botimport, aas_s::freelinks, aas_link_s::next_ent, numaaslinks, aas_link_s::prev_ent, and PRT_FATAL. Referenced by AAS_AASLinkEntity(). { aas_link_t *link; link = aasworld.freelinks; if (!link) { #ifndef BSPC if (bot_developer) #endif { botimport.Print(PRT_FATAL, "empty aas link heap\n"); } //end if return NULL; } //end if if (aasworld.freelinks) aasworld.freelinks = aasworld.freelinks->next_ent; if (aasworld.freelinks) aasworld.freelinks->prev_ent = NULL; numaaslinks--; return link; } //end of the function AAS_AllocAASLink

int AAS_AreaCluster (  int  areanum  )

Definition at line 308 of file be_aas_sample.c. References aasworld, aas_s::areasettings, botimport, aas_areasettings_s::cluster, aas_s::numareas, and PRT_ERROR. Referenced by AAS_FloodAreas(), AAS_FloodAreas_r(), and BotExportTest(). { if (areanum <= 0 || areanum >= aasworld.numareas) { botimport.Print(PRT_ERROR, "AAS_AreaCluster: invalid area number\n"); return 0; } //end if return aasworld.areasettings[areanum].cluster; } //end of the function AAS_AreaCluster

qboolean AAS_AreaEntityCollision (  int  areanum, vec3_t  start, vec3_t  end, int  presencetype, int  passent, aas_trace_t *  trace )

Definition at line 406 of file be_aas_sample.c. References AAS_EntityCollision(), aas_link_t, AAS_PresenceTypeBoundingBox(), aas_trace_t, aasworld, aas_trace_s::area, aas_s::arealinkedentities, bsp_trace_t, Com_Memset(), CONTENTS_PLAYERCLIP, CONTENTS_SOLID, aas_trace_s::endpos, bsp_trace_s::endpos, bsp_trace_s::ent, aas_trace_s::ent, aas_link_s::entnum, bsp_trace_s::fraction, aas_link_s::next_ent, aas_trace_s::planenum, qboolean, bsp_trace_s::startsolid, aas_trace_s::startsolid, vec3_t, and VectorCopy. Referenced by AAS_TraceClientBBox(). { int collision; vec3_t boxmins, boxmaxs; aas_link_t *link; bsp_trace_t bsptrace; AAS_PresenceTypeBoundingBox(presencetype, boxmins, boxmaxs); Com_Memset(&bsptrace, 0, sizeof(bsp_trace_t)); //make compiler happy //assume no collision bsptrace.fraction = 1; collision = qfalse; for (link = aasworld.arealinkedentities[areanum]; link; link = link->next_ent) { //ignore the pass entity if (link->entnum == passent) continue; // if (AAS_EntityCollision(link->entnum, start, boxmins, boxmaxs, end, CONTENTS_SOLID|CONTENTS_PLAYERCLIP, &bsptrace)) { collision = qtrue; } //end if } //end for if (collision) { trace->startsolid = bsptrace.startsolid; trace->ent = bsptrace.ent; VectorCopy(bsptrace.endpos, trace->endpos); trace->area = 0; trace->planenum = 0; return qtrue; } //end if return qfalse; } //end of the function AAS_AreaEntityCollision

Here is the call graph for this function:

aas_face_t* AAS_AreaGroundFace (  int  areanum, vec3_t  point )

Definition at line 1018 of file be_aas_sample.c. References aas_area_t, aas_face_t, AAS_InsideFace(), aasworld, abs(), aas_s::areas, f, aas_face_s::faceflags, aas_s::faceindex, aas_s::faces, aas_area_s::firstface, i, aas_s::loaded, aas_plane_s::normal, aas_area_s::numfaces, aas_face_s::planenum, aas_s::planes, point, up, vec3_t, VectorCopy, and VectorNegate. { int i, facenum; vec3_t up = {0, 0, 1}; vec3_t normal; aas_area_t *area; aas_face_t *face; if (!aasworld.loaded) return NULL; area = &aasworld.areas[areanum]; for (i = 0; i < area->numfaces; i++) { facenum = aasworld.faceindex[area->firstface + i]; face = &aasworld.faces[abs(facenum)]; //if this is a ground face if (face->faceflags & FACE_GROUND) { //get the up or down normal if (aasworld.planes[face->planenum].normal[2] < 0) VectorNegate(up, normal); else VectorCopy(up, normal); //check if the point is in the face if (AAS_InsideFace(face, normal, point, 0.01f)) return face; } //end if } //end for return NULL; } //end of the function AAS_AreaGroundFace

Here is the call graph for this function:

int AAS_AreaInfo (  int  areanum, aas_areainfo_t *  info )

Definition at line 1363 of file be_aas_sample.c. References aas_areainfo_t, aas_areasettings_t, aasworld, aas_areasettings_s::areaflags, aas_s::areas, aas_s::areasettings, botimport, aas_area_s::center, aas_areainfo_s::center, aas_areainfo_s::cluster, aas_areasettings_s::cluster, aas_areainfo_s::contents, aas_areasettings_s::contents, aas_areainfo_s::flags, aas_area_s::maxs, aas_areainfo_s::maxs, aas_area_s::mins, aas_areainfo_s::mins, aas_s::numareas, aas_areainfo_s::presencetype, aas_areasettings_s::presencetype, PRT_ERROR, and VectorCopy. { aas_areasettings_t *settings; if (!info) return 0; if (areanum <= 0 || areanum >= aasworld.numareas) { botimport.Print(PRT_ERROR, "AAS_AreaInfo: areanum %d out of range\n", areanum); return 0; } //end if settings = &aasworld.areasettings[areanum]; info->cluster = settings->cluster; info->contents = settings->contents; info->flags = settings->areaflags; info->presencetype = settings->presencetype; VectorCopy(aasworld.areas[areanum].mins, info->mins); VectorCopy(aasworld.areas[areanum].maxs, info->maxs); VectorCopy(aasworld.areas[areanum].center, info->center); return sizeof(aas_areainfo_t); } //end of the function AAS_AreaInfo

int AAS_AreaPresenceType (  int  areanum  )

Definition at line 324 of file be_aas_sample.c. References aasworld, aas_s::areasettings, botimport, aas_s::loaded, aas_s::numareas, aas_areasettings_s::presencetype, and PRT_ERROR. Referenced by AAS_Reachability_Grapple(), and BotTravel_Walk(). { if (!aasworld.loaded) return 0; if (areanum <= 0 || areanum >= aasworld.numareas) { botimport.Print(PRT_ERROR, "AAS_AreaPresenceType: invalid area number\n"); return 0; } //end if return aasworld.areasettings[areanum].presencetype; } //end of the function AAS_AreaPresenceType

int AAS_BBoxAreas (  vec3_t  absmins, vec3_t  absmaxs, int *  areas, int  maxareas )

Definition at line 1340 of file be_aas_sample.c. References AAS_AASLinkEntity(), aas_link_t, AAS_UnlinkFromAreas(), aas_link_s::areanum, and aas_link_s::next_area. { aas_link_t *linkedareas, *link; int num; linkedareas = AAS_AASLinkEntity(absmins, absmaxs, -1); num = 0; for (link = linkedareas; link; link = link->next_area) { areas[num] = link->areanum; num++; if (num >= maxareas) break; } //end for AAS_UnlinkFromAreas(linkedareas); return num; } //end of the function AAS_BBoxAreas

Here is the call graph for this function:

int AAS_BoxOnPlaneSide2 (  vec3_t  absmins, vec3_t  absmaxs, aas_plane_t *  p )

Definition at line 1127 of file be_aas_sample.c. References aas_plane_t, aas_plane_s::dist, DotProduct, i, aas_plane_s::normal, p, and vec3_t. Referenced by AAS_AASLinkEntity(). { int i, sides; float dist1, dist2; vec3_t corners[2]; for (i = 0; i < 3; i++) { if (p->normal[i] < 0) { corners[0][i] = absmins[i]; corners[1][i] = absmaxs[i]; } //end if else { corners[1][i] = absmins[i]; corners[0][i] = absmaxs[i]; } //end else } //end for dist1 = DotProduct(p->normal, corners[0]) - p->dist; dist2 = DotProduct(p->normal, corners[1]) - p->dist; sides = 0; if (dist1 >= 0) sides = 1; if (dist2 < 0) sides |= 2; return sides; } //end of the function AAS_BoxOnPlaneSide2

vec_t AAS_BoxOriginDistanceFromPlane (  vec3_t  normal, vec3_t  mins, vec3_t  maxs, int  side )

Definition at line 366 of file be_aas_sample.c. References DotProduct, i, v1, v2, vec3_t, vec_t, VectorCopy, and VectorInverse(). { vec3_t v1, v2; int i; //swap maxs and mins when on the other side of the plane if (side) { //get a point of the box that would be one of the first //to collide with the plane for (i = 0; i < 3; i++) { if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = maxs[i]; else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = mins[i]; else v1[i] = 0; } //end for } //end if else { //get a point of the box that would be one of the first //to collide with the plane for (i = 0; i < 3; i++) { if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = mins[i]; else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = maxs[i]; else v1[i] = 0; } //end for } //end else // VectorCopy(normal, v2); VectorInverse(v2); // VectorNegate(normal, v2); return DotProduct(v1, v2); } //end of the function AAS_BoxOriginDistanceFromPlane

Here is the call graph for this function:

void AAS_DeAllocAASLink (  aas_link_t *  link  )

Definition at line 172 of file be_aas_sample.c. References aas_link_t, aasworld, aas_s::freelinks, aas_link_s::next_area, aas_link_s::next_ent, numaaslinks, aas_link_s::prev_area, and aas_link_s::prev_ent. Referenced by AAS_UnlinkFromAreas(). { if (aasworld.freelinks) aasworld.freelinks->prev_ent = link; link->prev_ent = NULL; link->next_ent = aasworld.freelinks; link->prev_area = NULL; link->next_area = NULL; aasworld.freelinks = link; numaaslinks++; } //end of the function AAS_DeAllocAASLink

void AAS_FacePlane (  int  facenum, vec3_t  normal, float *  dist )

Definition at line 1052 of file be_aas_sample.c. References aas_plane_t, aasworld, aas_plane_s::dist, aas_s::faces, aas_plane_s::normal, aas_face_s::planenum, aas_s::planes, and VectorCopy. { aas_plane_t *plane; plane = &aasworld.planes[aasworld.faces[facenum].planenum]; VectorCopy(plane->normal, normal); *dist = plane->dist; } //end of the function AAS_FacePlane

void AAS_FreeAASLinkedEntities (  void   )

Definition at line 201 of file be_aas_sample.c. References aasworld, aas_s::arealinkedentities, and FreeMemory(). Referenced by AAS_Shutdown(). { if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities); aasworld.arealinkedentities = NULL; } //end of the function AAS_InitAASLinkedEntities

Here is the call graph for this function:

void AAS_FreeAASLinkHeap (  void   )

Definition at line 134 of file be_aas_sample.c. References aasworld, FreeMemory(), aas_s::linkheap, and aas_s::linkheapsize. Referenced by AAS_Shutdown(). { if (aasworld.linkheap) FreeMemory(aasworld.linkheap); aasworld.linkheap = NULL; aasworld.linkheapsize = 0; } //end of the function AAS_FreeAASLinkHeap

Here is the call graph for this function:

void AAS_InitAASLinkedEntities (  void   )

Definition at line 188 of file be_aas_sample.c. References aas_link_t, aasworld, aas_s::arealinkedentities, FreeMemory(), GetClearedHunkMemory(), aas_s::loaded, and aas_s::numareas. Referenced by AAS_CalcReachAndClusters(), and AAS_LoadMap(). { if (!aasworld.loaded) return; if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities); aasworld.arealinkedentities = (aas_link_t **) GetClearedHunkMemory( aasworld.numareas * sizeof(aas_link_t *)); } //end of the function AAS_InitAASLinkedEntities

Here is the call graph for this function:

void AAS_InitAASLinkHeap (  void   )

Definition at line 96 of file be_aas_sample.c. References aas_link_t, aasworld, aas_s::freelinks, GetHunkMemory(), i, LibVarValue(), aas_s::linkheap, aas_s::linkheapsize, aas_link_s::next_ent, numaaslinks, and aas_link_s::prev_ent. Referenced by AAS_CalcReachAndClusters(), and AAS_LoadMap(). { int i, max_aaslinks; max_aaslinks = aasworld.linkheapsize; //if there's no link heap present if (!aasworld.linkheap) { #ifdef BSPC max_aaslinks = 6144; #else max_aaslinks = (int) LibVarValue("max_aaslinks", "6144"); #endif if (max_aaslinks < 0) max_aaslinks = 0; aasworld.linkheapsize = max_aaslinks; aasworld.linkheap = (aas_link_t *) GetHunkMemory(max_aaslinks * sizeof(aas_link_t)); } //end if //link the links on the heap aasworld.linkheap[0].prev_ent = NULL; aasworld.linkheap[0].next_ent = &aasworld.linkheap[1]; for (i = 1; i < max_aaslinks-1; i++) { aasworld.linkheap[i].prev_ent = &aasworld.linkheap[i - 1]; aasworld.linkheap[i].next_ent = &aasworld.linkheap[i + 1]; } //end for aasworld.linkheap[max_aaslinks-1].prev_ent = &aasworld.linkheap[max_aaslinks-2]; aasworld.linkheap[max_aaslinks-1].next_ent = NULL; //pointer to the first free link aasworld.freelinks = &aasworld.linkheap[0]; // numaaslinks = max_aaslinks; } //end of the function AAS_InitAASLinkHeap

Here is the call graph for this function:

qboolean AAS_InsideFace (  aas_face_t *  face, vec3_t  pnormal, vec3_t  point, float  epsilon )

Definition at line 926 of file be_aas_sample.c. References aas_edge_t, aas_face_t, AAS_OrthogonalToVectors, aasworld, abs(), botimport, DotProduct, aas_s::edgeindex, aas_s::edges, aas_face_s::firstedge, i, aas_s::loaded, aas_face_s::numedges, point, PRT_MESSAGE, qboolean, aas_edge_s::v, vec3_t, VectorCopy, VectorSubtract, and aas_s::vertexes. Referenced by AAS_AreaGroundFace(), and AAS_TraceEndFace(). { int i, firstvertex, edgenum; vec3_t v0; vec3_t edgevec, pointvec, sepnormal; aas_edge_t *edge; #ifdef AAS_SAMPLE_DEBUG int lastvertex = 0; #endif //AAS_SAMPLE_DEBUG if (!aasworld.loaded) return qfalse; for (i = 0; i < face->numedges; i++) { edgenum = aasworld.edgeindex[face->firstedge + i]; edge = &aasworld.edges[abs(edgenum)]; //get the first vertex of the edge firstvertex = edgenum < 0; VectorCopy(aasworld.vertexes[edge->v[firstvertex]], v0); //edge vector VectorSubtract(aasworld.vertexes[edge->v[!firstvertex]], v0, edgevec); // #ifdef AAS_SAMPLE_DEBUG if (lastvertex && lastvertex != edge->v[firstvertex]) { botimport.Print(PRT_MESSAGE, "winding not counter clockwise\n"); } //end if lastvertex = edge->v[!firstvertex]; #endif //AAS_SAMPLE_DEBUG //vector from first edge point to point possible in face VectorSubtract(point, v0, pointvec); //get a vector pointing inside the face orthogonal to both the //edge vector and the normal vector of the plane the face is in //this vector defines a plane through the origin (first vertex of //edge) and through both the edge vector and the normal vector //of the plane AAS_OrthogonalToVectors(edgevec, pnormal, sepnormal); //check on wich side of the above plane the point is //this is done by checking the sign of the dot product of the //vector orthogonal vector from above and the vector from the //origin (first vertex of edge) to the point //if the dotproduct is smaller than zero the point is outside the face if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse; } //end for return qtrue; } //end of the function AAS_InsideFace

Here is the call graph for this function:

aas_link_t* AAS_LinkEntityClientBBox (  vec3_t  absmins, vec3_t  absmaxs, int  entnum, int  presencetype )

Definition at line 1323 of file be_aas_sample.c. References AAS_AASLinkEntity(), aas_link_t, AAS_PresenceTypeBoundingBox(), vec3_t, and VectorSubtract. Referenced by AAS_BestReachableArea(), AAS_BestReachableFromJumpPadArea(), AAS_Reachability_JumpPad(), AAS_Reachability_Teleport(), and AAS_UpdateEntity(). { vec3_t mins, maxs; vec3_t newabsmins, newabsmaxs; AAS_PresenceTypeBoundingBox(presencetype, mins, maxs); VectorSubtract(absmins, maxs, newabsmins); VectorSubtract(absmaxs, mins, newabsmaxs); //relink the entity return AAS_AASLinkEntity(newabsmins, newabsmaxs, entnum); } //end of the function AAS_LinkEntityClientBBox

Here is the call graph for this function:

aas_plane_t* AAS_PlaneFromNum (  int  planenum  )

Definition at line 1389 of file be_aas_sample.c. References aas_plane_t, aasworld, aas_s::loaded, and aas_s::planes. Referenced by AAS_ClientMovementPrediction(), and AAS_OnGround(). { if (!aasworld.loaded) return 0; return &aasworld.planes[planenum]; } //end of the function AAS_PlaneFromNum

int AAS_PointAreaNum (  vec3_t  point  )

Definition at line 213 of file be_aas_sample.c. References aas_node_t, aas_plane_t, aasworld, botimport, aas_node_s::children, aas_plane_s::dist, DotProduct, aas_s::loaded, aas_s::nodes, aas_plane_s::normal, aas_s::numnodes, aas_s::numplanes, aas_node_s::planenum, aas_s::planes, point, PRT_ERROR, PRT_MESSAGE, and vec_t. Referenced by AAS_AgainstLadder(), AAS_BestReachableArea(), AAS_ClientMovementPrediction(), AAS_FloodAreas(), AAS_NearbySolidOrGap(), AAS_PointPresenceType(), AAS_PointReachabilityAreaIndex(), AAS_RandomGoalArea(), AAS_Reachability_Elevator(), AAS_Reachability_FuncBobbing(), AAS_Reachability_Grapple(), AAS_Reachability_Ladder(), AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(), AAS_Reachability_Teleport(), AAS_Reachability_WalkOffLedge(), AAS_Reachability_WeaponJump(), BotFuzzyPointReachabilityArea(), BotInitInfoEntities(), BotTravel_Grapple(), and BotTravel_Jump(). { int nodenum; vec_t dist; aas_node_t *node; aas_plane_t *plane; if (!aasworld.loaded) { botimport.Print(PRT_ERROR, "AAS_PointAreaNum: aas not loaded\n"); return 0; } //end if //start with node 1 because node zero is a dummy used for solid leafs nodenum = 1; while (nodenum > 0) { // botimport.Print(PRT_MESSAGE, "[%d]", nodenum); #ifdef AAS_SAMPLE_DEBUG if (nodenum >= aasworld.numnodes) { botimport.Print(PRT_ERROR, "nodenum = %d >= aasworld.numnodes = %d\n", nodenum, aasworld.numnodes); return 0; } //end if #endif //AAS_SAMPLE_DEBUG node = &aasworld.nodes[nodenum]; #ifdef AAS_SAMPLE_DEBUG if (node->planenum < 0 || node->planenum >= aasworld.numplanes) { botimport.Print(PRT_ERROR, "node->planenum = %d >= aasworld.numplanes = %d\n", node->planenum, aasworld.numplanes); return 0; } //end if #endif //AAS_SAMPLE_DEBUG plane = &aasworld.planes[node->planenum]; dist = DotProduct(point, plane->normal) - plane->dist; if (dist > 0) nodenum = node->children[0]; else nodenum = node->children[1]; } //end while if (!nodenum) { #ifdef AAS_SAMPLE_DEBUG botimport.Print(PRT_MESSAGE, "in solid\n"); #endif //AAS_SAMPLE_DEBUG return 0; } //end if return -nodenum; } //end of the function AAS_PointAreaNum

qboolean AAS_PointInsideFace (  int  facenum, vec3_t  point, float  epsilon )

Definition at line 978 of file be_aas_sample.c. References aas_edge_t, aas_face_t, aas_plane_t, aasworld, abs(), CrossProduct(), DotProduct, aas_s::edgeindex, aas_s::edges, aas_s::faces, aas_face_s::firstedge, i, aas_s::loaded, aas_plane_s::normal, aas_face_s::numedges, aas_face_s::planenum, aas_s::planes, point, qboolean, aas_edge_s::v, v1, v2, vec3_t, vec_t, VectorSubtract, and aas_s::vertexes. Referenced by AAS_AgainstLadder(), and AAS_FindFaceReachabilities(). { int i, firstvertex, edgenum; vec_t *v1, *v2; vec3_t edgevec, pointvec, sepnormal; aas_edge_t *edge; aas_plane_t *plane; aas_face_t *face; if (!aasworld.loaded) return qfalse; face = &aasworld.faces[facenum]; plane = &aasworld.planes[face->planenum]; // for (i = 0; i < face->numedges; i++) { edgenum = aasworld.edgeindex[face->firstedge + i]; edge = &aasworld.edges[abs(edgenum)]; //get the first vertex of the edge firstvertex = edgenum < 0; v1 = aasworld.vertexes[edge->v[firstvertex]]; v2 = aasworld.