/**
* @brief Moves the given mins/maxs volume through the world from start to end.
* @note Passedict and edicts owned by passedict are explicitly not checked.
* @sa CL_ClipMoveToLEs
* @sa SV_Trace
* @param[in] traceLine Start and end vector of the trace
* @param[in] box The box we move through the world
* @param[in] passle Ignore this local entity in the trace (might be nullptr)
* @param[in] passle2 Ignore this local entity in the trace (might be nullptr)
* @param[in] contentmask Searched content the trace should watch for
* @param[in] worldLevel The worldlevel (0-7) to calculate the levelmask for the trace from
*/
trace_t CL_Trace (const Line& traceLine, const AABB& box, const le_t* passle, le_t* passle2, int contentmask, int worldLevel)
{
if (cl_trace_debug->integer)
R_DrawBoundingBoxBatched(box);
/* clip to world */
MoveClipCL clip;
clip.trace = CM_CompleteBoxTrace(cl.mapTiles, traceLine, box, (1 << (worldLevel + 1)) - 1, contentmask, 0);
clip.trace.le = nullptr;
if (clip.trace.fraction == 0)
return clip.trace; /* blocked by the world */
clip.contentmask = contentmask;
clip.moveLine.set(traceLine);
clip.objBox.set(box);
clip.passle = passle;
clip.passle2 = passle2;
/* create the bounding box of the entire move */
clip.calcBounds();
/* clip to other solid entities */
CL_ClipMoveToLEs(&clip);
return clip.trace;
}
/**
* @brief Performs box traces against the world and all inline models, gives the hit position back
* @param[in] mapTiles List of tiles the current (RMA-)map is composed of
* @param[in] traceLine The start/stop position of the trace.
* @param[in] traceBox The minimum/maximum extents of the collision box that is projected.
* @param[in] levelmask A mask of the game levels to trace against. Mask 0x100 filters clips.
* @param[in] brushmask Any brush detected must at least have one of these contents.
* @param[in] brushreject Any brush detected with any of these contents will be ignored.
* @param[in] list The local models list (a local model has a name starting with * followed by the model number)
* @return a trace_t with the information of the closest brush intersected.
* @sa CM_CompleteBoxTrace
* @sa CM_HintedTransformedBoxTrace
*/
trace_t CM_EntCompleteBoxTrace (mapTiles_t* mapTiles, const Line& traceLine, const AABB* traceBox, int levelmask, int brushmask, int brushreject, const char** list)
{
AABB lineBox(*traceBox);
lineBox.shift(traceLine.start); /* the traceBox in starting position */
AABB lineBoxTemp(*traceBox);
lineBoxTemp.shift(traceLine.stop); /* in end position */
lineBox.add(lineBoxTemp); /* bounding box for the whole trace */
/* Now lineBox specifies the whole volume to be traced through. */
/* reconstruct a levelmask */
const vec_t minZ = lineBox.getMinZ();
const vec_t maxZ = lineBox.getMaxZ();
int newLevelMask = 0;
if (levelmask & TL_FLAG_ACTORCLIP) /* if the passed levelmask contains the bit for the cliplevels, */
newLevelMask = TL_FLAG_ACTORCLIP; /* preserve it */
for (int i = 0; i < PATHFINDING_HEIGHT; i++) {
const vec_t lower = i * UNIT_HEIGHT; /* the height bounds of the level */
const vec_t upper = (i + 1) * UNIT_HEIGHT;
if (minZ > upper || maxZ < lower)
continue;
newLevelMask |= (1 << i);
}
/* trace against world first */
const trace_t tr = CM_CompleteBoxTrace(mapTiles, traceLine, *traceBox, newLevelMask, brushmask, brushreject);
if (!list || tr.fraction == 0.0)
return tr;
trace_t trace = tr;
for (const char** name = list; *name; name++) {
/* check whether this is really an inline model */
if (*name[0] != '*')
Com_Error(ERR_DROP, "name in the inlineList is no inline model: '%s'", *name);
const cBspModel_t* model = CM_InlineModel(mapTiles, *name);
assert(model);
if (model->headnode >= mapTiles->mapTiles[model->tile].numnodes + 6)
continue;
AABB modelBox;
/* Quickly calculate the bounds of this model to see if they can overlap. */
CM_CalculateWidestBoundingBox(model, modelBox);
/* If the bounds of the extents box and the line do not overlap, then skip tracing this model. */
if (!lineBox.doesIntersect(modelBox))
continue;
const trace_t newtr = CM_HintedTransformedBoxTrace(mapTiles->mapTiles[model->tile], traceLine, *traceBox,
model->headnode, brushmask, brushreject, model->origin, model->angles, model->shift, trace.fraction);
/* memorize the trace with the minimal fraction */
if (newtr.fraction == 0.0)
return newtr;
if (newtr.fraction < trace.fraction)
trace = newtr;
}
return trace;
}
/**
* @brief Performs box traces against the world and all inline models, gives the hit position back
* @param[in] mapTiles List of tiles the current (RMA-)map is composed of
* @param[in] start The position to start the trace.
* @param[in] end The position where the trace ends.
* @param[in] traceBox The minimum/maximum extents of the collision box that is projected.
* @param[in] levelmask A mask of the game levels to trace against. Mask 0x100 filters clips.
* @param[in] brushmask Any brush detected must at least have one of these contents.
* @param[in] brushreject Any brush detected with any of these contents will be ignored.
* @param[in] list The local models list (a local model has a name starting with * followed by the model number)
* @return a trace_t with the information of the closest brush intersected.
* @sa CM_CompleteBoxTrace
* @sa CM_HintedTransformedBoxTrace
*/
trace_t CM_EntCompleteBoxTrace (mapTiles_t *mapTiles, const vec3_t start, const vec3_t end, const AABB* traceBox, int levelmask, int brushmask, int brushreject, const char **list)
{
trace_t trace, newtr;
const char **name;
vec3_t bmins, bmaxs;
/* trace against world first */
trace = CM_CompleteBoxTrace(mapTiles, start, end, *traceBox, levelmask, brushmask, brushreject);
if (!list || trace.fraction == 0.0)
return trace;
/* Find the original bounding box for the tracing line. */
VectorSet(bmins, std::min(start[0], end[0]), std::min(start[1], end[1]), std::min(start[2], end[2]));
VectorSet(bmaxs, std::max(start[0], end[0]), std::max(start[1], end[1]), std::max(start[2], end[2]));
/* Now increase the bounding box by mins and maxs in both directions. */
VectorAdd(bmins, traceBox->mins, bmins);
VectorAdd(bmaxs, traceBox->maxs, bmaxs);
/* Now bmins and bmaxs specify the whole volume to be traced through. */
for (name = list; *name; name++) {
vec3_t amins, amaxs;
const cBspModel_t *model;
/* check whether this is really an inline model */
if (*name[0] != '*')
Com_Error(ERR_DROP, "name in the inlineList is no inline model: '%s'", *name);
model = CM_InlineModel(mapTiles, *name);
assert(model);
if (model->headnode >= mapTiles->mapTiles[model->tile].numnodes + 6)
continue;
/* Quickly calculate the bounds of this model to see if they can overlap. */
CM_CalculateBoundingBox(model, amins, amaxs);
/* If the bounds of the extents box and the line do not overlap, then skip tracing this model. */
if (bmins[0] > amaxs[0]
|| bmins[1] > amaxs[1]
|| bmins[2] > amaxs[2]
|| bmaxs[0] < amins[0]
|| bmaxs[1] < amins[1]
|| bmaxs[2] < amins[2])
continue;
newtr = CM_HintedTransformedBoxTrace(&mapTiles->mapTiles[model->tile], start, end, traceBox->mins, traceBox->maxs,
model->headnode, brushmask, brushreject, model->origin, model->angles, model->shift, trace.fraction);
/* memorize the trace with the minimal fraction */
if (newtr.fraction == 0.0)
return newtr;
if (newtr.fraction < trace.fraction)
trace = newtr;
}
return trace;
}
/**
* @brief Moves the given mins/maxs volume through the world from start to end.
* @param[in] start Start vector to start the trace from
* @param[in] end End vector to stop the trace at
* @param[in] size Bounding box size used for tracing
* @param[in] contentmask Searched content the trace should watch for
*/
void R_Trace (const vec3_t start, const vec3_t end, float size, int contentmask)
{
vec3_t mins, maxs;
float frac;
trace_t tr;
int i;
r_locals.tracenum++;
if (r_locals.tracenum > 0xffff) /* avoid overflows */
r_locals.tracenum = 0;
VectorSet(mins, -size, -size, -size);
VectorSet(maxs, size, size, size);
refdef.trace = CM_CompleteBoxTrace(refdef.mapTiles, start, end, mins, maxs, TRACING_ALL_VISIBLE_LEVELS, contentmask, 0);
refdef.traceEntity = NULL;
frac = refdef.trace.fraction;
/* check bsp models */
for (i = 0; i < refdef.numEntities; i++) {
entity_t *ent = R_GetEntity(i);
const model_t *m = ent->model;
if (!m || m->type != mod_bsp_submodel)
continue;
tr = CM_TransformedBoxTrace(&(refdef.mapTiles->mapTiles[m->bsp.maptile]), start, end, mins, maxs, m->bsp.firstnode,
contentmask, 0, ent->origin, ent->angles);
if (tr.fraction < frac) {
refdef.trace = tr;
refdef.traceEntity = ent;
frac = tr.fraction;
}
}
assert(refdef.trace.mapTile >= 0);
assert(refdef.trace.mapTile < r_numMapTiles);
}