/* DESCRIPTION: SV_ClipMoveToEntity/SV_SingleClipMoveToEntity
// LOCATION: world.c
// PATH: Mostly in this file.
//
// SV_ClipMoveToEntity is a proxy (and only access point) for the next one.
//
// The function seems to be related to collision detection.
*/
void SV_SingleClipMoveToEntity(edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, trace_t * Outgoing_Trace) {
vec3_t var_c;
vec3_t var_18;
vec3_t var_24;
hull_t * var_28;
// int var_2c;
int var_30;
int var_34;
int var_38;
vec3_t forward;
vec3_t right;
vec3_t up;
vec3_t var_68;
int var_6c;
trace_t var_a4;
vec3_t var_bc;
vec3_t var_c8;
vec3_t var_d4;
Q_memset(Outgoing_Trace, 0, sizeof(trace_t));
Outgoing_Trace->fraction = 1.0;
Outgoing_Trace->allsolid = 1;
Outgoing_Trace->endpos[0] = end[0];
Outgoing_Trace->endpos[1] = end[1];
Outgoing_Trace->endpos[2] = end[2];
if(global_sv.models[ent->v.modelindex]->modeltype == 3) {
//taken: 1616, -528, 127.97 endpos
var_28 = SV_HullForStudioModel(ent, mins, maxs, var_c, &var_30);
}
else {
var_28 = SV_HullForEntity(ent, mins, maxs, var_c);
var_30 = 1; //if model?
}
VectorSubtract(start, var_c, var_18);
VectorSubtract(end, var_c, var_24);
if((ent->v.solid != SOLID_BSP) ||
(ent->v.angles[0] == 0 && ent->v.angles[1] == 0 && ent->v.angles[2] == 0)) {
//taken
var_38 = 0; //rotated prob
}
else { var_38 = 1; }
if(var_38) { //This is another function in QW.
AngleVectors(ent->v.angles, forward, right, up); //v.angles is def +58.
VectorCopy(var_18, var_68);
var_18[0] = DotProduct(var_68, forward);
var_18[1] = -DotProduct(var_68, right);
var_18[2] = DotProduct(var_68, up);
VectorCopy(var_24, var_68);
var_24[0] = DotProduct(var_68, forward);
var_24[1] = -DotProduct(var_68, right);
var_24[2] = DotProduct(var_68, up);
} //Curiously enough, I'm taking linear algebra right now. I hate it.
//= 20
if(var_30 == 1) {
SV_RecursiveHullCheck(var_28, var_28->firstclipnode, 0, 1.0, var_18, var_24, Outgoing_Trace);
}
else {
for(var_6c = 0, var_34 = 0; var_34 < var_30; var_34++) {
Q_memset(&var_a4, 0, sizeof(trace_t));
var_a4.fraction = 1.0;
var_a4.allsolid = 1;
VectorCopy(end, var_a4.endpos);
SV_RecursiveHullCheck(&(var_28[var_34]), var_28[var_34].firstclipnode, 0, 1.0, var_18, var_24, &var_a4);
if(var_34 != 0 && var_a4.startsolid == 0 && var_a4.allsolid == 0 &&
var_a4.fraction > Outgoing_Trace->fraction) { continue; }
if(Outgoing_Trace->startsolid == 0) {
Q_memcpy(Outgoing_Trace, &var_a4, sizeof(trace_t));
}
else {
Q_memcpy(Outgoing_Trace, &var_a4, sizeof(trace_t)); //Probably could be a bit more efficient here.
Outgoing_Trace->startsolid = 1;
}
var_6c = var_34;
}
Outgoing_Trace->hitgroup = SV_HitgroupForStudioHull(var_6c);
}
if(Outgoing_Trace->fraction != 1.0) {
if(var_38 != 0) {
AngleVectorsTranspose(ent->v.angles, var_68, var_bc, var_c8);
VectorCopy(Outgoing_Trace->plane.normal, var_d4);
Outgoing_Trace->plane.normal[0] = DotProduct(var_d4, var_68);
Outgoing_Trace->plane.normal[1] = -DotProduct(var_d4, var_bc);
Outgoing_Trace->plane.normal[2] = DotProduct(var_d4, var_c8);
}
//Scaling, clearly.
Outgoing_Trace->endpos[0] = start[0] + (Outgoing_Trace->fraction * (end[0] - start[0]));
Outgoing_Trace->endpos[1] = start[1] + (Outgoing_Trace->fraction * (end[1] - start[1]));
Outgoing_Trace->endpos[2] = start[2] + (Outgoing_Trace->fraction * (end[2] - start[2]));
}
if(Outgoing_Trace->fraction < 1.0 || Outgoing_Trace->startsolid != 0) {
Outgoing_Trace->pHit = ent;
}
}
/*
================
PM_DrawPhysEntBBox(int num)
================
*/
void PM_DrawPhysEntBBox(int num, int pcolor, float life)
{
physent_t *pe;
vec3_t org;
int j;
vec3_t tmp;
vec3_t p[8];
float gap = BOX_GAP;
vec3_t modelmins, modelmaxs;
if (num >= pmove->numphysent ||
num <= 0)
return;
pe = &pmove->physents[num];
if (pe->model)
{
VectorCopy(pe->origin, org);
pmove->PM_GetModelBounds( pe->model, modelmins, modelmaxs );
for (j = 0; j < 8; j++)
{
tmp[0] = (j & 1) ? modelmins[0] - gap : modelmaxs[0] + gap;
tmp[1] = (j & 2) ? modelmins[1] - gap : modelmaxs[1] + gap;
tmp[2] = (j & 4) ? modelmins[2] - gap : modelmaxs[2] + gap;
VectorCopy(tmp, p[j]);
}
// If the bbox should be rotated, do that
if (pe->angles[0] || pe->angles[1] || pe->angles[2])
{
vec3_t forward, right, up;
AngleVectorsTranspose(pe->angles, forward, right, up);
for (j = 0; j < 8; j++)
{
VectorCopy(p[j], tmp);
p[j][0] = DotProduct ( tmp, forward );
p[j][1] = DotProduct ( tmp, right );
p[j][2] = DotProduct ( tmp, up );
}
}
// Offset by entity origin, if any.
for (j = 0; j < 8; j++)
VectorAdd(p[j], org, p[j]);
for (j = 0; j < 6; j++)
{
PM_DrawRectangle(
p[PM_boxpnt[j][1]],
p[PM_boxpnt[j][0]],
p[PM_boxpnt[j][2]],
p[PM_boxpnt[j][3]],
pcolor, life);
}
}
else
{
for (j = 0; j < 8; j++)
{
tmp[0] = (j & 1) ? pe->mins[0] : pe->maxs[0];
tmp[1] = (j & 2) ? pe->mins[1] : pe->maxs[1];
tmp[2] = (j & 4) ? pe->mins[2] : pe->maxs[2];
VectorAdd(tmp, pe->origin, tmp);
VectorCopy(tmp, p[j]);
}
for (j = 0; j < 6; j++)
{
PM_DrawRectangle(
p[PM_boxpnt[j][1]],
p[PM_boxpnt[j][0]],
p[PM_boxpnt[j][2]],
p[PM_boxpnt[j][3]],
pcolor, life);
}
}
}
