sv_world.c File Reference

#include "server.h"

Include dependency graph for sv_world.c:

Go to the source code of this file.

Data Structures
struct	areaParms_t
struct	moveclip_t
struct	worldSector_s
Defines
#define	AREA_DEPTH   4
#define	AREA_NODES   64
#define	MAX_TOTAL_ENT_LEAFS   128
Typedefs
typedef worldSector_s	worldSector_t
Functions
int	SV_AreaEntities (const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount)
void	SV_AreaEntities_r (worldSector_t *node, areaParms_t *ap)
void	SV_ClearWorld (void)
clipHandle_t	SV_ClipHandleForEntity (const sharedEntity_t *ent)
void	SV_ClipMoveToEntities (moveclip_t *clip)
void	SV_ClipToEntity (trace_t *trace, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int entityNum, int contentmask, int capsule)
worldSector_t *	SV_CreateworldSector (int depth, vec3_t mins, vec3_t maxs)
void	SV_LinkEntity (sharedEntity_t *gEnt)
int	SV_PointContents (const vec3_t p, int passEntityNum)
void	SV_SectorList_f (void)
void	SV_Trace (trace_t *results, const vec3_t start, vec3_t mins, vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int capsule)
void	SV_UnlinkEntity (sharedEntity_t *gEnt)
Variables
int	sv_numworldSectors
worldSector_t	sv_worldSectors [AREA_NODES]

---

Define Documentation

#define AREA_DEPTH   4

Definition at line 71 of file sv_world.c.

#define AREA_NODES   64

Definition at line 72 of file sv_world.c.

#define MAX_TOTAL_ENT_LEAFS   128

Definition at line 204 of file sv_world.c. Referenced by SV_LinkEntity().

---

Typedef Documentation

typedef struct worldSector_s worldSector_t

Referenced by SV_AreaEntities_r(), SV_CreateworldSector(), SV_LinkEntity(), SV_SectorList_f(), and SV_UnlinkEntity().

---

Function Documentation

int SV_AreaEntities (  const vec3_t  mins, const vec3_t  maxs, int *  entityList, int  maxcount )

Definition at line 430 of file sv_world.c. References areaParms_t::count, areaParms_t::list, areaParms_t::maxcount, areaParms_t::maxs, areaParms_t::mins, SV_AreaEntities_r(), and sv_worldSectors. Referenced by SV_ClipMoveToEntities(), SV_GameSystemCalls(), and SV_PointContents(). { areaParms_t ap; ap.mins = mins; ap.maxs = maxs; ap.list = entityList; ap.count = 0; ap.maxcount = maxcount; SV_AreaEntities_r( sv_worldSectors, &ap ); return ap.count; }

Here is the call graph for this function:

void SV_AreaEntities_r (  worldSector_t *  node, areaParms_t *  ap )

Definition at line 382 of file sv_world.c. References entityShared_t::absmax, entityShared_t::absmin, worldSector_s::axis, check(), worldSector_s::children, Com_Printf(), areaParms_t::count, count, worldSector_s::dist, worldSector_s::entities, areaParms_t::list, areaParms_t::maxcount, areaParms_t::maxs, areaParms_t::mins, next, svEntity_s::nextEntityInWorldSector, sharedEntity_t::r, sv, SV_GEntityForSvEntity(), server_t::svEntities, svEntity_t, and worldSector_t. Referenced by SV_AreaEntities(). { svEntity_t *check, *next; sharedEntity_t *gcheck; int count; count = 0; for ( check = node->entities ; check ; check = next ) { next = check->nextEntityInWorldSector; gcheck = SV_GEntityForSvEntity( check ); if ( gcheck->r.absmin[0] > ap->maxs[0] || gcheck->r.absmin[1] > ap->maxs[1] || gcheck->r.absmin[2] > ap->maxs[2] || gcheck->r.absmax[0] < ap->mins[0] || gcheck->r.absmax[1] < ap->mins[1] || gcheck->r.absmax[2] < ap->mins[2]) { continue; } if ( ap->count == ap->maxcount ) { Com_Printf ("SV_AreaEntities: MAXCOUNT\n"); return; } ap->list[ap->count] = check - sv.svEntities; ap->count++; } if (node->axis == -1) { return; // terminal node } // recurse down both sides if ( ap->maxs[node->axis] > node->dist ) { SV_AreaEntities_r ( node->children[0], ap ); } if ( ap->mins[node->axis] < node->dist ) { SV_AreaEntities_r ( node->children[1], ap ); } }

Here is the call graph for this function:

void SV_ClearWorld (  void   )

Definition at line 147 of file sv_world.c. References clipHandle_t, CM_InlineModel(), CM_ModelBounds(), Com_Memset(), h(), SV_CreateworldSector(), sv_numworldSectors, sv_worldSectors, and vec3_t. Referenced by SV_SpawnServer(). { clipHandle_t h; vec3_t mins, maxs; Com_Memset( sv_worldSectors, 0, sizeof(sv_worldSectors) ); sv_numworldSectors = 0; // get world map bounds h = CM_InlineModel( 0 ); CM_ModelBounds( h, mins, maxs ); SV_CreateworldSector( 0, mins, maxs ); }

Here is the call graph for this function:

clipHandle_t SV_ClipHandleForEntity (  const sharedEntity_t *  ent  )

Definition at line 35 of file sv_world.c. References entityShared_t::bmodel, clipHandle_t, CM_InlineModel(), CM_TempBoxModel(), entityShared_t::maxs, entityShared_t::mins, entityState_s::modelindex, qfalse, qtrue, sharedEntity_t::r, sharedEntity_t::s, and entityShared_t::svFlags. Referenced by SV_ClipMoveToEntities(), SV_ClipToEntity(), SV_EntityContact(), and SV_PointContents(). { if ( ent->r.bmodel ) { // explicit hulls in the BSP model return CM_InlineModel( ent->s.modelindex ); } if ( ent->r.svFlags & SVF_CAPSULE ) { // create a temp capsule from bounding box sizes return CM_TempBoxModel( ent->r.mins, ent->r.maxs, qtrue ); } // create a temp tree from bounding box sizes return CM_TempBoxModel( ent->r.mins, ent->r.maxs, qfalse ); }

Here is the call graph for this function:

void SV_ClipMoveToEntities (  moveclip_t *  clip  )

Definition at line 510 of file sv_world.c. References trace_t::allsolid, entityShared_t::bmodel, moveclip_t::boxmaxs, moveclip_t::boxmins, moveclip_t::capsule, clipHandle_t, CM_TransformedBoxTrace(), moveclip_t::contentmask, entityShared_t::contents, entityShared_t::currentAngles, entityShared_t::currentOrigin, moveclip_t::end, trace_t::entityNum, trace_t::fraction, i, MAX_GENTITIES, moveclip_t::maxs, moveclip_t::mins, entityState_s::number, entityShared_t::ownerNum, moveclip_t::passEntityNum, qboolean, sharedEntity_t::r, sharedEntity_t::s, moveclip_t::start, trace_t::startsolid, SV_AreaEntities(), SV_ClipHandleForEntity(), SV_GentityNum(), and moveclip_t::trace. Referenced by SV_Trace(). { int i, num; int touchlist[MAX_GENTITIES]; sharedEntity_t *touch; int passOwnerNum; trace_t trace; clipHandle_t clipHandle; float *origin, *angles; num = SV_AreaEntities( clip->boxmins, clip->boxmaxs, touchlist, MAX_GENTITIES); if ( clip->passEntityNum != ENTITYNUM_NONE ) { passOwnerNum = ( SV_GentityNum( clip->passEntityNum ) )->r.ownerNum; if ( passOwnerNum == ENTITYNUM_NONE ) { passOwnerNum = -1; } } else { passOwnerNum = -1; } for ( i=0 ; i<num ; i++ ) { if ( clip->trace.allsolid ) { return; } touch = SV_GentityNum( touchlist[i] ); // see if we should ignore this entity if ( clip->passEntityNum != ENTITYNUM_NONE ) { if ( touchlist[i] == clip->passEntityNum ) { continue; // don't clip against the pass entity } if ( touch->r.ownerNum == clip->passEntityNum ) { continue; // don't clip against own missiles } if ( touch->r.ownerNum == passOwnerNum ) { continue; // don't clip against other missiles from our owner } } // if it doesn't have any brushes of a type we // are looking for, ignore it if ( ! ( clip->contentmask & touch->r.contents ) ) { continue; } // might intersect, so do an exact clip clipHandle = SV_ClipHandleForEntity (touch); origin = touch->r.currentOrigin; angles = touch->r.currentAngles; if ( !touch->r.bmodel ) { angles = vec3_origin; // boxes don't rotate } CM_TransformedBoxTrace ( &trace, (float *)clip->start, (float *)clip->end, (float *)clip->mins, (float *)clip->maxs, clipHandle, clip->contentmask, origin, angles, clip->capsule); if ( trace.allsolid ) { clip->trace.allsolid = qtrue; trace.entityNum = touch->s.number; } else if ( trace.startsolid ) { clip->trace.startsolid = qtrue; trace.entityNum = touch->s.number; } if ( trace.fraction < clip->trace.fraction ) { qboolean oldStart; // make sure we keep a startsolid from a previous trace oldStart = clip->trace.startsolid; trace.entityNum = touch->s.number; clip->trace = trace; clip->trace.startsolid |= oldStart; } } }

Here is the call graph for this function:

void SV_ClipToEntity (  trace_t *  trace, const vec3_t  start, const vec3_t  mins, const vec3_t  maxs, const vec3_t  end, int  entityNum, int  contentmask, int  capsule )

Definition at line 468 of file sv_world.c. References entityShared_t::bmodel, clipHandle_t, CM_TransformedBoxTrace(), Com_Memset(), entityShared_t::contents, entityShared_t::currentAngles, entityShared_t::currentOrigin, trace_t::entityNum, trace_t::fraction, entityState_s::number, sharedEntity_t::r, sharedEntity_t::s, SV_ClipHandleForEntity(), and SV_GentityNum(). Referenced by BotImport_EntityTrace(). { sharedEntity_t *touch; clipHandle_t clipHandle; float *origin, *angles; touch = SV_GentityNum( entityNum ); Com_Memset(trace, 0, sizeof(trace_t)); // if it doesn't have any brushes of a type we // are looking for, ignore it if ( ! ( contentmask & touch->r.contents ) ) { trace->fraction = 1.0; return; } // might intersect, so do an exact clip clipHandle = SV_ClipHandleForEntity (touch); origin = touch->r.currentOrigin; angles = touch->r.currentAngles; if ( !touch->r.bmodel ) { angles = vec3_origin; // boxes don't rotate } CM_TransformedBoxTrace ( trace, (float *)start, (float *)end, (float *)mins, (float *)maxs, clipHandle, contentmask, origin, angles, capsule); if ( trace->fraction < 1 ) { trace->entityNum = touch->s.number; } }

Here is the call graph for this function:

worldSector_t* SV_CreateworldSector (  int  depth, vec3_t  mins, vec3_t  maxs )

Definition at line 106 of file sv_world.c. References worldSector_s::axis, worldSector_s::children, worldSector_s::dist, sv_numworldSectors, sv_worldSectors, vec3_t, VectorCopy, VectorSubtract, and worldSector_t. Referenced by SV_ClearWorld(). { worldSector_t *anode; vec3_t size; vec3_t mins1, maxs1, mins2, maxs2; anode = &sv_worldSectors[sv_numworldSectors]; sv_numworldSectors++; if (depth == AREA_DEPTH) { anode->axis = -1; anode->children[0] = anode->children[1] = NULL; return anode; } VectorSubtract (maxs, mins, size); if (size[0] > size[1]) { anode->axis = 0; } else { anode->axis = 1; } anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]); VectorCopy (mins, mins1); VectorCopy (mins, mins2); VectorCopy (maxs, maxs1); VectorCopy (maxs, maxs2); maxs1[anode->axis] = mins2[anode->axis] = anode->dist; anode->children[0] = SV_CreateworldSector (depth+1, mins2, maxs2); anode->children[1] = SV_CreateworldSector (depth+1, mins1, maxs1); return anode; }

void SV_LinkEntity (  sharedEntity_t *  gEnt  )

Definition at line 205 of file sv_world.c. References entityShared_t::absmax, entityShared_t::absmin, svEntity_s::areanum, svEntity_s::areanum2, worldSector_s::axis, entityShared_t::bmodel, worldSector_s::children, svEntity_s::clusternums, CM_BoxLeafnums(), CM_LeafArea(), CM_LeafCluster(), Com_DPrintf(), entityShared_t::contents, CONTENTS_SOLID, entityShared_t::currentAngles, entityShared_t::currentOrigin, worldSector_s::dist, worldSector_s::entities, i, j, k, svEntity_s::lastCluster, leafs, entityShared_t::linkcount, entityShared_t::linked, max, MAX_TOTAL_ENT_LEAFS, entityShared_t::maxs, entityShared_t::mins, svEntity_s::nextEntityInWorldSector, entityState_s::number, svEntity_s::numClusters, sharedEntity_t::r, RadiusFromBounds(), sharedEntity_t::s, entityState_s::solid, server_t::state, sv, SV_SvEntityForGentity(), SV_UnlinkEntity(), svEntity_t, VectorAdd, svEntity_s::worldSector, and worldSector_t. Referenced by SV_GameSystemCalls(), and SV_SetBrushModel(). { worldSector_t *node; int leafs[MAX_TOTAL_ENT_LEAFS]; int cluster; int num_leafs; int i, j, k; int area; int lastLeaf; float *origin, *angles; svEntity_t *ent; ent = SV_SvEntityForGentity( gEnt ); if ( ent->worldSector ) { SV_UnlinkEntity( gEnt ); // unlink from old position } // encode the size into the entityState_t for client prediction if ( gEnt->r.bmodel ) { gEnt->s.solid = SOLID_BMODEL; // a solid_box will never create this value } else if ( gEnt->r.contents & ( CONTENTS_SOLID | CONTENTS_BODY ) ) { // assume that x/y are equal and symetric i = gEnt->r.maxs[0]; if (i<1) i = 1; if (i>255) i = 255; // z is not symetric j = (-gEnt->r.mins[2]); if (j<1) j = 1; if (j>255) j = 255; // and z maxs can be negative... k = (gEnt->r.maxs[2]+32); if (k<1) k = 1; if (k>255) k = 255; gEnt->s.solid = (k<<16) | (j<<8) | i; } else { gEnt->s.solid = 0; } // get the position origin = gEnt->r.currentOrigin; angles = gEnt->r.currentAngles; // set the abs box if ( gEnt->r.bmodel && (angles[0] || angles[1] || angles[2]) ) { // expand for rotation float max; int i; max = RadiusFromBounds( gEnt->r.mins, gEnt->r.maxs ); for (i=0 ; i<3 ; i++) { gEnt->r.absmin[i] = origin[i] - max; gEnt->r.absmax[i] = origin[i] + max; } } else { // normal VectorAdd (origin, gEnt->r.mins, gEnt->r.absmin); VectorAdd (origin, gEnt->r.maxs, gEnt->r.absmax); } // because movement is clipped an epsilon away from an actual edge, // we must fully check even when bounding boxes don't quite touch gEnt->r.absmin[0] -= 1; gEnt->r.absmin[1] -= 1; gEnt->r.absmin[2] -= 1; gEnt->r.absmax[0] += 1; gEnt->r.absmax[1] += 1; gEnt->r.absmax[2] += 1; // link to PVS leafs ent->numClusters = 0; ent->lastCluster = 0; ent->areanum = -1; ent->areanum2 = -1; //get all leafs, including solids num_leafs = CM_BoxLeafnums( gEnt->r.absmin, gEnt->r.absmax, leafs, MAX_TOTAL_ENT_LEAFS, &lastLeaf ); // if none of the leafs were inside the map, the // entity is outside the world and can be considered unlinked if ( !num_leafs ) { return; } // set areas, even from clusters that don't fit in the entity array for (i=0 ; i<num_leafs ; i++) { area = CM_LeafArea (leafs[i]); if (area != -1) { // doors may legally straggle two areas, // but nothing should evern need more than that if (ent->areanum != -1 && ent->areanum != area) { if (ent->areanum2 != -1 && ent->areanum2 != area && sv.state == SS_LOADING) { Com_DPrintf ("Object %i touching 3 areas at %f %f %f\n", gEnt->s.number, gEnt->r.absmin[0], gEnt->r.absmin[1], gEnt->r.absmin[2]); } ent->areanum2 = area; } else { ent->areanum = area; } } } // store as many explicit clusters as we can ent->numClusters = 0; for (i=0 ; i < num_leafs ; i++) { cluster = CM_LeafCluster( leafs[i] ); if ( cluster != -1 ) { ent->clusternums[ent->numClusters++] = cluster; if ( ent->numClusters == MAX_ENT_CLUSTERS ) { break; } } } // store off a last cluster if we need to if ( i != num_leafs ) { ent->lastCluster = CM_LeafCluster( lastLeaf ); } gEnt->r.linkcount++; // find the first world sector node that the ent's box crosses node = sv_worldSectors; while (1) { if (node->axis == -1) break; if ( gEnt->r.absmin[node->axis] > node->dist) node = node->children[0]; else if ( gEnt->r.absmax[node->axis] < node->dist) node = node->children[1]; else break; // crosses the node } // link it in ent->worldSector = node; ent->nextEntityInWorldSector = node->entities; node->entities = ent; gEnt->r.linked = qtrue; }

Here is the call graph for this function:

int SV_PointContents (  const vec3_t  p, int  passEntityNum )

Definition at line 657 of file sv_world.c. References entityState_s::angles, entityShared_t::bmodel, clipHandle_t, CM_PointContents(), CM_TransformedPointContents(), i, MAX_GENTITIES, entityState_s::origin, p, sharedEntity_t::r, sharedEntity_t::s, SV_AreaEntities(), SV_ClipHandleForEntity(), and SV_GentityNum(). Referenced by BotImport_PointContents(), and SV_GameSystemCalls(). { int touch[MAX_GENTITIES]; sharedEntity_t *hit; int i, num; int contents, c2; clipHandle_t clipHandle; float *angles; // get base contents from world contents = CM_PointContents( p, 0 ); // or in contents from all the other entities num = SV_AreaEntities( p, p, touch, MAX_GENTITIES ); for ( i=0 ; i<num ; i++ ) { if ( touch[i] == passEntityNum ) { continue; } hit = SV_GentityNum( touch[i] ); // might intersect, so do an exact clip clipHandle = SV_ClipHandleForEntity( hit ); angles = hit->s.angles; if ( !hit->r.bmodel ) { angles = vec3_origin; // boxes don't rotate } c2 = CM_TransformedPointContents (p, clipHandle, hit->s.origin, hit->s.angles); contents |= c2; } return contents; }

Here is the call graph for this function:

void SV_SectorList_f (  void   )

Definition at line 83 of file sv_world.c. References c, Com_Printf(), worldSector_s::entities, i, svEntity_s::nextEntityInWorldSector, sv_worldSectors, svEntity_t, and worldSector_t. Referenced by SV_AddOperatorCommands(). { int i, c; worldSector_t *sec; svEntity_t *ent; for ( i = 0 ; i < AREA_NODES ; i++ ) { sec = &sv_worldSectors[i]; c = 0; for ( ent = sec->entities ; ent ; ent = ent->nextEntityInWorldSector ) { c++; } Com_Printf( "sector %i: %i entities\n", i, c ); } }

Here is the call graph for this function:

void SV_Trace (  trace_t *  results, const vec3_t  start, vec3_t  mins, vec3_t  maxs, const vec3_t  end, int  passEntityNum, int  contentmask, int  capsule )

Definition at line 600 of file sv_world.c. References moveclip_t::boxmaxs, moveclip_t::boxmins, moveclip_t::capsule, CM_BoxTrace(), Com_Memset(), moveclip_t::contentmask, moveclip_t::end, trace_t::entityNum, ENTITYNUM_WORLD, trace_t::fraction, i, moveclip_t::maxs, moveclip_t::mins, moveclip_t::passEntityNum, moveclip_t::start, SV_ClipMoveToEntities(), moveclip_t::trace, and VectorCopy. Referenced by BotImport_Trace(), and SV_GameSystemCalls(). { moveclip_t clip; int i; if ( !mins ) { mins = vec3_origin; } if ( !maxs ) { maxs = vec3_origin; } Com_Memset ( &clip, 0, sizeof ( moveclip_t ) ); // clip to world CM_BoxTrace( &clip.trace, start, end, mins, maxs, 0, contentmask, capsule ); clip.trace.entityNum = clip.trace.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE; if ( clip.trace.fraction == 0 ) { *results = clip.trace; return; // blocked immediately by the world } clip.contentmask = contentmask; clip.start = start; // VectorCopy( clip.trace.endpos, clip.end ); VectorCopy( end, clip.end ); clip.mins = mins; clip.maxs = maxs; clip.passEntityNum = passEntityNum; clip.capsule = capsule; // create the bounding box of the entire move // we can limit it to the part of the move not // already clipped off by the world, which can be // a significant savings for line of sight and shot traces for ( i=0 ; i<3 ; i++ ) { if ( end[i] > start[i] ) { clip.boxmins[i] = clip.start[i] + clip.mins[i] - 1; clip.boxmaxs[i] = clip.end[i] + clip.maxs[i] + 1; } else { clip.boxmins[i] = clip.end[i] + clip.mins[i] - 1; clip.boxmaxs[i] = clip.start[i] + clip.maxs[i] + 1; } } // clip to other solid entities SV_ClipMoveToEntities ( &clip ); *results = clip.trace; }

Here is the call graph for this function:

void SV_UnlinkEntity (  sharedEntity_t *  gEnt  )

Definition at line 167 of file sv_world.c. References Com_Printf(), worldSector_s::entities, entityShared_t::linked, svEntity_s::nextEntityInWorldSector, sharedEntity_t::r, SV_SvEntityForGentity(), svEntity_t, svEntity_s::worldSector, and worldSector_t. Referenced by SV_GameSystemCalls(), and SV_LinkEntity(). { svEntity_t *ent; svEntity_t *scan; worldSector_t *ws; ent = SV_SvEntityForGentity( gEnt ); gEnt->r.linked = qfalse; ws = ent->worldSector; if ( !ws ) { return; // not linked in anywhere } ent->worldSector = NULL; if ( ws->entities == ent ) { ws->entities = ent->nextEntityInWorldSector; return; } for ( scan = ws->entities ; scan ; scan = scan->nextEntityInWorldSector ) { if ( scan->nextEntityInWorldSector == ent ) { scan->nextEntityInWorldSector = ent->nextEntityInWorldSector; return; } } Com_Printf( "WARNING: SV_UnlinkEntity: not found in worldSector\n" ); }

Here is the call graph for this function:

---

Variable Documentation

int sv_numworldSectors

Definition at line 75 of file sv_world.c. Referenced by SV_ClearWorld(), and SV_CreateworldSector().

worldSector_t sv_worldSectors[AREA_NODES]

Definition at line 74 of file sv_world.c. Referenced by SV_AreaEntities(), SV_ClearWorld(), SV_CreateworldSector(), and SV_SectorList_f().

---