eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity
fteqw/engine/server/world.c
Spoike 6c5de8e8b1 Added pm_pground cvar for compat with mvdsv/ezquake. Do not use it with NQ mods however, as the QC will interfere with the onground state (QW mods are okay). 
Added Z_EXT_PF_ONGROUND + Z_EXT_PF_SOLID for compat (not enabled serverside due to conflicts with pext - just a define away).
Fixed bug with loading screens switching sizes part way through loading.
Added hexen2 rain effect.
Fix hexen2 model texture alphas not working.
Fix potential linux crash from excessively long stdin lines.
Added cl_rollalpha cvar.
Fixed quirk where the player would slide along the base of steep walls/slopes.
Tweaked PM_NudgePosition to be more precise, giving more reliable prediction.
Fixed fread qc builtin.
Tweaked random() builtin to bias slightly away from 0, so that nextthink=random()*foo; will never cause statue-monsters.
Check for GL_WEBGL_depth_texture instead of just GL_OES_depth_texture, to fix compressedTex2d errors in firefox.
Second attempt at blocking invariant keyword with mesa.
Use xrandr for gamma where possible. This prevents reading stale XF86 gamma ramps and restoring those invalid ramps when quitting.
Try to grab mouse pointers slightly faster in x11.
Don't call XIFreeDeviceInfo if XIQueryDevice returned NULL.
Document parm_string and startspot qc globals.
Fix possible infinite loop from physics frames.
QTV: stripped most of the old plugin code (because really, who has a browser that still supports either ActiveX or NPAPI). Fixed up emscripten port references.
QTV: fix bug with protocol extensions not being reported to viewers.
QTV: use binary websockets instead of text.



git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5419 fc73d0e0-1445-4013-8a0c-d673dee63da5
2019-03-01 22:39:30 +00:00

3122 lines
82 KiB
C
Raw Blame History

/*
Copyright (C) 1996-1997 Id Software, Inc.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// world.c -- world query functions
#include "quakedef.h"
#include "pr_common.h"
#if defined(CSQC_DAT) || !defined(CLIENTONLY)
/*
entities never clip against themselves, or their owner
line of sight checks trace->crosscontent, but bullets don't
*/
size_t areagridsequence; //used to avoid poking the same ent twice.
extern cvar_t sv_compatiblehulls;
extern cvar_t sv_gameplayfix_nolinknonsolid;
typedef struct
{
vec3_t boxmins, boxmaxs;// enclose the test object along entire move
float *mins, *maxs; // size of the moving object
vec3_t mins2, maxs2; // size when clipping against mosnters
float *start, *end;
trace_t trace;
int type;
int hitcontentsmask;
wedict_t *passedict;
#ifdef Q2SERVER
q2edict_t *q2passedict;
#endif
int hullnum;
qboolean capsule;
} moveclip_t;
/*
===============================================================================
HULL BOXES
===============================================================================
*/
static hull_t box_hull;
static mclipnode_t box_clipnodes[6];
static mplane_t box_planes[6];
/*
===================
SV_InitBoxHull
Set up the planes and clipnodes so that the six floats of a bounding box
can just be stored out and get a proper hull_t structure.
===================
*/
static void World_InitBoxHull (void)
{
int i;
int side;
box_hull.clipnodes = box_clipnodes;
box_hull.planes = box_planes;
box_hull.firstclipnode = 0;
box_hull.lastclipnode = 5;
for (i=0 ; i<6 ; i++)
{
box_clipnodes[i].planenum = i;
side = i&1;
box_clipnodes[i].children[side] = Q1CONTENTS_EMPTY;
if (i != 5)
box_clipnodes[i].children[side^1] = i + 1;
else
box_clipnodes[i].children[side^1] = Q1CONTENTS_SOLID;
box_planes[i].type = i>>1;
box_planes[i].normal[i>>1] = 1;
}
}
/*
===================
SV_HullForBox
To keep everything totally uniform, bounding boxes are turned into small
BSP trees instead of being compared directly.
===================
*/
hull_t *World_HullForBox (vec3_t mins, vec3_t maxs)
{
box_planes[0].dist = maxs[0];
box_planes[1].dist = mins[0];
box_planes[2].dist = maxs[1];
box_planes[3].dist = mins[1];
box_planes[4].dist = maxs[2];
box_planes[5].dist = mins[2];
return &box_hull;
}
model_t mod_capsule;
qboolean World_BoxTrace(struct model_s *model, int hulloverride, int frame, vec3_t axis[3], vec3_t p1, vec3_t p2, vec3_t mins, vec3_t maxs, unsigned int against, struct trace_s *trace)
{
hull_t *hull = &box_hull;
//bbox vs bbox
//capsule vs bbox (NYI)
memset (trace, 0, sizeof(trace_t));
trace->fraction = 1;
trace->allsolid = true;
VectorCopy (p2, trace->endpos);
return Q1BSP_RecursiveHullCheck (hull, hull->firstclipnode, p1, p2, against, trace);
}
qboolean World_CapsuleTrace(struct model_s *model, int hulloverride, framestate_t *framestate, vec3_t axis[3], vec3_t p1, vec3_t p2, vec3_t mins, vec3_t maxs, qboolean capsule, unsigned int against, struct trace_s *trace)
{
//bbox vs capsule (NYI)
//capsule vs capsule (NYI)
memset (trace, 0, sizeof(trace_t));
trace->fraction = 1;
trace->allsolid = false;
VectorCopy(p2, trace->endpos);
if (capsule)
{ //capsule vs capsule.
//no orientation support on either (ignore axis)
float sr = ((model->maxs[0]-model->mins[0]) + (model->maxs[1]-model->mins[1]))/4.0;
float sh = (model->maxs[2]-model->mins[2]) - sr*2;
float mr = ((maxs[0]-mins[0]) + (maxs[1]-mins[1]))/4.0;
float mh = (maxs[2]-mins[2]) - mr*2;
vec3_t sup = {0, 0, 1};
vec3_t dir, sright;
vec4_t nearestplane;
float d1, d2;
vec3_t nearestpoint;
float neardist;
//expand the static capsule's height+radius by the mover's height+radius, so that its point+capsule instead
sr += mr;
sh += mh;
VectorSubtract(p1, p2, dir);
d2=VectorNormalize(dir);
CrossProduct(sup, dir, sright);
VectorNormalize(sright);
CrossProduct(sup, sright, nearestplane);
VectorNormalize(nearestplane);
nearestplane[3] = DotProduct(vec3_origin, nearestplane); //capsule is at 0 0 0
d1 = DotProduct(nearestplane, p1) - nearestplane[3];
d2 = DotProduct(nearestplane, p2) - nearestplane[3];
d2 = -d1 /(d1+d2);
VectorInterpolate(p1, d2, p2, nearestpoint);
neardist = VectorLength(nearestpoint);
if (neardist < sr)
{
float x, y, oz, nz;
//sqrt(h*h-(x*x+y*y))=z
//change the hypotenuse from the messed up value to the actual radius
//and update z to match the changed h
x = DotProduct(sup, nearestpoint) - 0;
y = DotProduct(sright, nearestpoint) - 0;
oz = DotProduct(nearestplane, nearestpoint) - nearestplane[3];
nz = sqrt(sr*sr - (x*x+y*y));
VectorMA(nearestpoint, nz-oz, dir, trace->endpos);
trace->fraction = 0;
}
}
return false;
}
model_t *World_CapsuleForBox(vec3_t mins, vec3_t maxs)
{
VectorCopy(mins, mod_capsule.mins);
VectorCopy(maxs, mod_capsule.maxs);
mod_capsule.funcs.NativeTrace = World_CapsuleTrace;
return &mod_capsule;
}
/*
===============================================================================
ENTITY AREA CHECKING
===============================================================================
*/
#if defined(Q2SERVER) || !defined(USEAREAGRID)
/*
===============
SV_CreateAreaNode
===============
*/
static areanode_t *World_CreateAreaNode (world_t *w, int depth, vec3_t mins, vec3_t maxs)
{
areanode_t *anode;
vec3_t size;
vec3_t mins1, maxs1, mins2, maxs2;
anode = &w->areanodes[w->numareanodes];
w->numareanodes++;
ClearLink (&anode->edicts);
VectorSubtract (maxs, mins, size);
if (depth == w->areanodedepth || (size[0] < 512 && size[1] < 512))
{
anode->axis = -1;
anode->children[0] = anode->children[1] = NULL;
return anode;
}
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] = World_CreateAreaNode (w, depth+1, mins2, maxs2);
anode->children[1] = World_CreateAreaNode (w, depth+1, mins1, maxs1);
return anode;
}
/*
===============
SV_ClearWorld
===============
*/
void World_ClearWorld_Nodes (world_t *w, qboolean relink)
{
#if !defined(USEAREAGRID)
int i;
wedict_t *ent;
#endif
int maxdepth;
vec3_t mins, maxs;
if (w->worldmodel)
{
VectorCopy(w->worldmodel->mins, mins);
VectorCopy(w->worldmodel->maxs, maxs);
}
else
{
VectorSet(mins, -4096, -4096, -4096);
VectorSet(maxs, 4096, 4096, 4096);
}
World_InitBoxHull ();
#if !defined(USEAREAGRID)
memset (&w->portallist, 0, sizeof(w->portallist));
ClearLink (&w->portallist.edicts);
w->portallist.axis = -1;
#endif
maxdepth = 8;
if (!w->areanodes || w->areanodedepth != maxdepth)
{
Z_Free(w->areanodes);
w->areanodedepth = maxdepth;
w->areanodes = Z_Malloc(sizeof(*w->areanodes) * (pow(2, w->areanodedepth+1)-1));
}
else
memset (w->areanodes, 0, sizeof(*w->areanodes)*w->numareanodes);
w->numareanodes = 0;
World_CreateAreaNode (w, 0, mins, maxs);
#if !defined(USEAREAGRID)
if (relink)
{
for (i=0 ; i<w->num_edicts ; i++)
{
ent = WEDICT_NUM_PB(w->progs, i);
if (!ent)
continue;
ent->area.prev = ent->area.next = NULL;
if (ED_ISFREE(ent))
continue;
World_LinkEdict (w, ent, false); // relink ents so touch functions continue to work.
}
}
#endif
}
#endif
#ifdef USEAREAGRID
static void World_ClearWorld_AreaGrid (world_t *w, qboolean relink)
{
int numareas = 1;
int i, j;
wedict_t *ent;
vec3_t mins, maxs, size;
if (w->worldmodel)
{
VectorCopy(w->worldmodel->mins, mins);
VectorCopy(w->worldmodel->maxs, maxs);
}
else
{
VectorSet(mins, -4096, -4096, -4096);
VectorSet(maxs, 4096, 4096, 4096);
}
Vector2Set(w->gridsize, 128, 128);
for (i = 0; i < 2; i++)
{
size[i] = maxs[i] - mins[i];
size[i] /= w->gridsize[i];
//enforce a minimum grid size, so things don't end up getting added to every single node
if (size[i] < 128)
{
mins[i] -= (128-size[i])/2 * w->gridsize[i];
size[i] = 128;
}
w->gridscale[i] = size[i];
w->gridbias[i] = -mins[i];
numareas *= w->gridsize[i];
}
World_InitBoxHull ();
if (w->gridareas)
memset (w->gridareas, 0, sizeof(*w->gridareas)*numareas);
else
w->gridareas = Z_Malloc(sizeof(*w->gridareas)*numareas);
for (i = 0; i < numareas; i++)
ClearLink (&w->gridareas[i].l);
ClearLink (&w->jumboarea.l);
ClearLink (&w->portallist.l);
if (relink)
{
for (i=0 ; i<w->num_edicts ; i++)
{
ent = WEDICT_NUM_PB(w->progs, i);
if (!ent)
continue;
for (j = 0; j < countof(ent->gridareas); j++)
{
if (!ent->gridareas[j].l.prev)
break; // not linked in anywhere
ClearLink(&ent->gridareas[j].l);
}
if (ED_ISFREE(ent))
continue;
World_LinkEdict (w, ent, false); // relink ents so touch functions continue to work.
}
}
}
#endif
void World_ClearWorld (world_t *w, qboolean relink)
{
#ifdef Q2SERVER
if (w == &sv.world && svs.gametype == GT_QUAKE2)
World_ClearWorld_Nodes(w, relink);
else
#endif
{
#ifdef USEAREAGRID
World_ClearWorld_AreaGrid(w, relink);
#else
World_ClearWorld_Nodes(w, relink);
#endif
}
}
#if !defined(USEAREAGRID)
/*
===============
SV_UnlinkEdict
===============
*/
void World_UnlinkEdict (wedict_t *ent)
{
if (!ent->area.prev)
return; // not linked in anywhere
RemoveLink (&ent->area);
ent->area.prev = ent->area.next = NULL;
}
/*
====================
SV_TouchLinks
====================
*/
void World_TouchLinks (world_t *w, wedict_t *ent, areanode_t *node)
{
static wedict_t *nodelinks[256]; //all this means is that any more than this will not touch. probably you won't have that many valid triggers
link_t *l, *next;
wedict_t *touch;
int linkcount = 0, ln;
//work out who they are first.
for (l = node->edicts.next ; l != &node->edicts ; l = next)
{
if (linkcount == countof(nodelinks))
break;
next = l->next;
touch = EDICT_FROM_AREA(l);
if (touch == ent)
continue;
if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
continue;
if (ent->v->absmin[0] > touch->v->absmax[0]
|| ent->v->absmin[1] > touch->v->absmax[1]
|| ent->v->absmin[2] > touch->v->absmax[2]
|| ent->v->absmax[0] < touch->v->absmin[0]
|| ent->v->absmax[1] < touch->v->absmin[1]
|| ent->v->absmax[2] < touch->v->absmin[2] )
continue;
if (!((int)ent->xv->dimension_solid & (int)touch->xv->dimension_hit))
continue;
nodelinks[linkcount++] = touch;
}
for (ln = 0; ln < linkcount; ln++)
{
touch = nodelinks[ln];
//make sure nothing moved it away
if (ED_ISFREE(touch))
continue;
if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
continue;
if (ent->v->absmin[0] > touch->v->absmax[0]
|| ent->v->absmin[1] > touch->v->absmax[1]
|| ent->v->absmin[2] > touch->v->absmax[2]
|| ent->v->absmax[0] < touch->v->absmin[0]
|| ent->v->absmax[1] < touch->v->absmin[1]
|| ent->v->absmax[2] < touch->v->absmin[2] )
continue;
if (!((int)ent->xv->dimension_solid & (int)touch->xv->dimension_hit)) //didn't change did it?...
continue;
w->Event_Touch(w, touch, ent, NULL);
if (ED_ISFREE(ent))
break;
}
// recurse down both sides
if (node->axis == -1 || ED_ISFREE(ent))
return;
if (ent->v->absmax[node->axis] > node->dist)
World_TouchLinks (w, ent, node->children[0]);
if (ent->v->absmin[node->axis] < node->dist)
World_TouchLinks (w, ent, node->children[1]);
}
#endif
/*
===============
SV_LinkEdict
===============
*/
void QDECL World_LinkEdict (world_t *w, wedict_t *ent, qboolean touch_triggers)
{
#ifdef USEAREAGRID
World_UnlinkEdict (ent); // unlink from old position
#else
areanode_t *node;
if (ent->area.prev)
World_UnlinkEdict (ent); // unlink from old position
#endif
if (ent == w->edicts)
return; // don't add the world
if (ED_ISFREE(ent))
return;
// set the abs box
if (ent->v->solid == SOLID_BSP &&
(ent->v->angles[0] || ent->v->angles[1] || ent->v->angles[2]) )
{ // expand for rotation
#if 1
int i;
float v;
float max;
//q2 method
max = 0;
for (i=0 ; i<3 ; i++)
{
v =fabs( ent->v->mins[i]);
if (v > max)
max = v;
v =fabs( ent->v->maxs[i]);
if (v > max)
max = v;
}
for (i=0 ; i<3 ; i++)
{
ent->v->absmin[i] = ent->v->origin[i] - max;
ent->v->absmax[i] = ent->v->origin[i] + max;
}
#else
int i;
vec3_t f, r, u;
vec3_t mn, mx;
//we need to link to the correct leaves
AngleVectors(ent->v->angles, f,r,u);
mn[0] = DotProduct(ent->v->mins, f);
mn[1] = -DotProduct(ent->v->mins, r);
mn[2] = DotProduct(ent->v->mins, u);
mx[0] = DotProduct(ent->v->maxs, f);
mx[1] = -DotProduct(ent->v->maxs, r);
mx[2] = DotProduct(ent->v->maxs, u);
for (i = 0; i < 3; i++)
{
if (mn[i] < mx[i])
{
ent->v->absmin[i] = ent->v->origin[i]+mn[i]-0.1;
ent->v->absmax[i] = ent->v->origin[i]+mx[i]+0.1;
}
else
{ //box went inside out
ent->v->absmin[i] = ent->v->origin[i]+mx[i]-0.1;
ent->v->absmax[i] = ent->v->origin[i]+mn[i]+0.1;
}
}
#endif
}
else
{
VectorAdd (ent->v->origin, ent->v->mins, ent->v->absmin);
VectorAdd (ent->v->origin, ent->v->maxs, ent->v->absmax);
}
//some fancy things can mean the ent's aabb is larger than its collision box.
#ifdef USERBE
// if (ent->rbe.body.body)
// w->rbe->ExpandBodyAABB(w->rbe, &ent->rbe.body, ent->v->absmin, env->v->absmax);
#endif
#ifdef SKELETALOBJECTS
if (ent->xv->skeletonindex)
skel_updateentbounds(w, ent);
#endif
if (!ent->v->solid)
ent->solidsize = ES_SOLID_BSP;
else
{
model_t *mod;
if (ent->v->solid == SOLID_BSP)
mod = w->Get_CModel(w, ent->v->modelindex);
else
mod = NULL;
if (mod && mod->type == mod_brush)
ent->solidsize = ES_SOLID_BSP;
else
ent->solidsize = COM_EncodeSize(ent->v->mins, ent->v->maxs);
}
//
// to make items easier to pick up and allow them to be grabbed off
// of shelves, the abs sizes are expanded
//
if ((int)ent->v->flags & FL_ITEM)
{
ent->v->absmin[0] -= 15;
ent->v->absmin[1] -= 15;
ent->v->absmin[2] -= 1;
ent->v->absmax[0] += 15;
ent->v->absmax[1] += 15;
ent->v->absmax[2] += 1;
}
else
{ // because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
ent->v->absmin[0] -= 1;
ent->v->absmin[1] -= 1;
ent->v->absmin[2] -= 1;
ent->v->absmax[0] += 1;
ent->v->absmax[1] += 1;
ent->v->absmax[2] += 1;
}
// link to PVS leafs
if (w->worldmodel && w->worldmodel->loadstate == MLS_LOADED && w->worldmodel->funcs.FindTouchedLeafs)
{
w->worldmodel->funcs.FindTouchedLeafs(w->worldmodel, &ent->pvsinfo, ent->v->absmin, ent->v->absmax);
}
if (ent->v->solid == SOLID_NOT && !sv_gameplayfix_nolinknonsolid.ival)
return;
#ifdef USEAREAGRID
// find the first node that the ent's box crosses
if (ent->v->solid == SOLID_PORTAL)
{
ent->gridareas[0].ed = ent;
InsertLinkBefore (&ent->gridareas[0].l, &w->portallist.l);
}
else
{
int ming[2], maxg[2], g[2], ga;
CALCAREAGRIDBOUNDS(w, ent->v->absmin, ent->v->absmax);
if ((maxg[0]-ming[0])*(maxg[1]-ming[1]) > countof(ent->gridareas) //entity is too large to fit in our grid.
|| ming[0]<0||ming[1]<0||maxg[0]>=w->gridsize[0]||maxg[1]>=w->gridsize[1]) //entity crosses the boundary of the world.
{ //shove it in the overflow
ent->gridareas[0].ed = ent;
InsertLinkBefore (&ent->gridareas[0].l, &w->jumboarea.l);
}
else
{
for (ga = 0, g[0] = ming[0]; g[0] < maxg[0]; g[0]++)
for ( g[1] = ming[1]; g[1] < maxg[1]; g[1]++, ga++)
{
ent->gridareas[ga].ed = ent;
InsertLinkBefore (&ent->gridareas[ga].l, &w->gridareas[g[0] + g[1]*w->gridsize[0]].l);
}
}
}
#else
// find the first node that the ent's box crosses
if (ent->v->solid == SOLID_PORTAL)
node = &w->portallist;
else
{
node = w->areanodes;
while (1)
{
if (node->axis == -1)
break;
if (ent->v->absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->v->absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
}
// link it in
InsertLinkBefore (&ent->area, &node->edicts);
#endif
// if touch_triggers, touch all entities at this node and decend for more
if (touch_triggers && ent->v->solid != SOLID_NOT)
World_TouchAllLinks (w, ent);
}
#ifdef Q2SERVER
void VARGS WorldQ2_UnlinkEdict(world_t *w, q2edict_t *ent)
{
if (!ent->area.prev)
return; // not linked in anywhere
RemoveLink (&ent->area);
ent->area.prev = ent->area.next = NULL;
}
void VARGS WorldQ2_LinkEdict(world_t *w, q2edict_t *ent)
{
areanode_t *node;
int leafs[128];
int clusters[countof(leafs)];
int num_leafs;
int i, j;
int area;
int topnode;
if (ent->area.prev)
WorldQ2_UnlinkEdict (w, ent); // unlink from old position
if (ent == ge->edicts)
return; // don't add the world
if (!ent->inuse)
return;
// set the size
VectorSubtract (ent->maxs, ent->mins, ent->size);
// encode the size into the entity_state for client prediction
if (ent->solid == Q2SOLID_BBOX && !(ent->svflags & SVF_DEADMONSTER))
{ // assume that x/y are equal and symetric
ent->s.solid = COM_EncodeSize(ent->mins, ent->maxs);
/*
i = ent->maxs[0]/8;
if (i<1)
i = 1;
if (i>31)
i = 31;
// z is not symetric
j = (-ent->mins[2])/8;
if (j<1)
j = 1;
if (j>31)
j = 31;
// and z maxs can be negative...
k = (ent->maxs[2]+32)/8;
if (k<1)
k = 1;
if (k>63)
k = 63;
//fixme: 32bit?
ent->s.solid = (k<<10) | (j<<5) | i;*/
}
else if (ent->solid == Q2SOLID_BSP)
{
ent->s.solid = ES_SOLID_BSP; // a solid_bbox will never create this value
}
else
ent->s.solid = 0;
// set the abs box
if (ent->solid == Q2SOLID_BSP &&
(ent->s.angles[0] || ent->s.angles[1] || ent->s.angles[2]) )
{ // expand for rotation
float max, v;
int i;
max = 0;
for (i=0 ; i<3 ; i++)
{
v =fabs( ent->mins[i]);
if (v > max)
max = v;
v =fabs( ent->maxs[i]);
if (v > max)
max = v;
}
for (i=0 ; i<3 ; i++)
{
ent->absmin[i] = ent->s.origin[i] - max;
ent->absmax[i] = ent->s.origin[i] + max;
}
}
else
{ // normal
VectorAdd (ent->s.origin, ent->mins, ent->absmin);
VectorAdd (ent->s.origin, ent->maxs, ent->absmax);
}
// because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
ent->absmin[0] -= 1;
ent->absmin[1] -= 1;
ent->absmin[2] -= 1;
ent->absmax[0] += 1;
ent->absmax[1] += 1;
ent->absmax[2] += 1;
// link to PVS leafs
ent->num_clusters = 0;
ent->areanum = 0;
ent->areanum2 = 0;
//get all leafs, including solids
num_leafs = CM_BoxLeafnums (w->worldmodel, ent->absmin, ent->absmax,
leafs, countof(leafs), &topnode);
// set areas
for (i=0 ; i<num_leafs ; i++)
{
clusters[i] = CM_LeafCluster (w->worldmodel, leafs[i]);
area = CM_LeafArea (w->worldmodel, leafs[i]);
if (area)
{ // doors may legally straggle two areas,
// but nothing should evern need more than that
if (ent->areanum && ent->areanum != area)
ent->areanum2 = area;
else
ent->areanum = area;
}
}
if (num_leafs >= countof(leafs))
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
}
else
{
ent->num_clusters = 0;
for (i=0 ; i<num_leafs ; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j=0 ; j<i ; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_clusters == MAX_ENT_CLUSTERS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
break;
}
ent->clusternums[ent->num_clusters++] = clusters[i];
}
}
}
// if first time, make sure old_origin is valid
if (!ent->linkcount)
{
VectorCopy (ent->s.origin, ent->s.old_origin);
}
ent->linkcount++;
if (ent->solid == Q2SOLID_NOT)
return;
// find the first node that the ent's box crosses
node = w->areanodes;
while (1)
{
if (node->axis == -1)
break;
if (ent->absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
// link it in
InsertLinkBefore (&ent->area, &node->edicts);
}
void WorldQ2_Q1BSP_LinkEdict(world_t *w, q2edict_t *ent)
{
areanode_t *node;
int i, j, k;
if (ent->area.prev)
WorldQ2_UnlinkEdict (w, ent); // unlink from old position
if (ent == ge->edicts)
return; // don't add the world
if (!ent->inuse)
return;
// set the size
VectorSubtract (ent->maxs, ent->mins, ent->size);
// encode the size into the entity_state for client prediction
if (ent->solid == Q2SOLID_BBOX && !(ent->svflags & SVF_DEADMONSTER))
{ // assume that x/y are equal and symetric
i = ent->maxs[0]/8;
if (i<1)
i = 1;
if (i>31)
i = 31;
// z is not symetric
j = (-ent->mins[2])/8;
if (j<1)
j = 1;
if (j>31)
j = 31;
// and z maxs can be negative...
k = (ent->maxs[2]+32)/8;
if (k<1)
k = 1;
if (k>63)
k = 63;
ent->s.solid = (k<<10) | (j<<5) | i;
}
else if (ent->solid == Q2SOLID_BSP)
{
ent->s.solid = 31; // a solid_bbox will never create this value
}
else
ent->s.solid = 0;
// set the abs box
if (ent->solid == Q2SOLID_BSP &&
(ent->s.angles[0] || ent->s.angles[1] || ent->s.angles[2]) )
{ // expand for rotation
float max, v;
int i;
max = 0;
for (i=0 ; i<3 ; i++)
{
v =fabs( ent->mins[i]);
if (v > max)
max = v;
v =fabs( ent->maxs[i]);
if (v > max)
max = v;
}
for (i=0 ; i<3 ; i++)
{
ent->absmin[i] = ent->s.origin[i] - max;
ent->absmax[i] = ent->s.origin[i] + max;
}
}
else
{ // normal
VectorAdd (ent->s.origin, ent->mins, ent->absmin);
VectorAdd (ent->s.origin, ent->maxs, ent->absmax);
}
// because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
ent->absmin[0] -= 1;
ent->absmin[1] -= 1;
ent->absmin[2] -= 1;
ent->absmax[0] += 1;
ent->absmax[1] += 1;
ent->absmax[2] += 1;
// link to PVS leafs
ent->num_clusters = 0;
ent->areanum = 0;
ent->areanum2 = 0;
ent->areanum = 1;
/*
//get all leafs, including solids
num_leafs = CM_BoxLeafnums (ent->absmin, ent->absmax,
leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
// set areas
for (i=0 ; i<num_leafs ; i++)
{
clusters[i] = CM_LeafCluster (leafs[i]);
area = CM_LeafArea (leafs[i]);
if (area)
{ // doors may legally straggle two areas,
// but nothing should evern need more than that
if (ent->areanum && ent->areanum != area)
{
ent->areanum2 = area;
}
else
ent->areanum = area;
}
}
if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
}
else
{
ent->num_clusters = 0;
for (i=0 ; i<num_leafs ; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j=0 ; j<i ; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_clusters == MAX_ENT_CLUSTERS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
break;
}
ent->clusternums[ent->num_clusters++] = clusters[i];
}
}
}
*/
// if first time, make sure old_origin is valid
if (!ent->linkcount)
{
VectorCopy (ent->s.origin, ent->s.old_origin);
}
ent->linkcount++;
if (ent->solid == Q2SOLID_NOT)
return;
// find the first node that the ent's box crosses
node = w->areanodes;
while (1)
{
if (node->axis == -1)
break;
if (ent->absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
// link it in
InsertLinkBefore (&ent->area, &node->edicts);
}
#endif
#if defined(Q2BSPS) || defined(Q3BSPS)
void Q23BSP_FindTouchedLeafs(model_t *model, struct pvscache_s *ent, float *mins, float *maxs)
{
#define MAX_TOTAL_ENT_LEAFS 128
int leafs[MAX_TOTAL_ENT_LEAFS];
int clusters[MAX_TOTAL_ENT_LEAFS];
int num_leafs;
int topnode;
int i, j;
int area;
int nullarea = (model->fromgame == fg_quake2)?0:-1;
//ent->num_leafs == q2's ent->num_clusters
ent->num_leafs = 0;
ent->areanum = nullarea;
ent->areanum2 = nullarea;
if (!mins || !maxs)
return;
//get all leafs, including solids
num_leafs = CM_BoxLeafnums (model, mins, maxs,
leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
// set areas
for (i=0 ; i<num_leafs ; i++)
{
clusters[i] = CM_LeafCluster (model, leafs[i]);
area = CM_LeafArea (model, leafs[i]);
if (area != nullarea)
{ // doors may legally straggle two areas,
// but nothing should ever need more than that
if (ent->areanum != nullarea && ent->areanum != area)
ent->areanum2 = area;
else
ent->areanum = area;
}
}
if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_leafs = -1;
ent->headnode = topnode;
}
else
{
ent->num_leafs = 0;
for (i=0 ; i<num_leafs ; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j=0 ; j<i ; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_leafs == MAX_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_leafs = -1;
ent->headnode = topnode;
break;
}
ent->leafnums[ent->num_leafs++] = clusters[i];
}
}
}
}
#endif
/*
===============================================================================
POINT TESTING IN HULLS
===============================================================================
*/
/*
==================
SV_PointContents
==================
*/
int World_PointContents (world_t *w, vec3_t p)
{
return w->worldmodel->funcs.PointContents(w->worldmodel, NULL, p);
}
//===========================================================================
/*
============
SV_TestEntityPosition
A small wrapper around SV_BoxInSolidEntity that never clips against the
supplied entity.
============
*/
wedict_t *World_TestEntityPosition (world_t *w, wedict_t *ent)
{
trace_t trace;
trace = World_Move (w, ent->v->origin, ent->v->mins, ent->v->maxs, ent->v->origin, ((ent->v->solid == SOLID_NOT || ent->v->solid == SOLID_TRIGGER)?MOVE_NOMONSTERS:0), ent);
if (trace.startsolid || trace.allsolid)
return trace.ent?trace.ent:w->edicts;
return NULL;
}
//wrapper function. Rotates the start and end positions around the angles if needed.
//qboolean TransformedHullCheck (hull_t *hull, vec3_t start, vec3_t end, trace_t *trace, vec3_t angles)
qboolean World_TransformedTrace (struct model_s *model, int hulloverride, framestate_t *framestate, vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, qboolean capsule, struct trace_s *trace, vec3_t origin, vec3_t angles, unsigned int hitcontentsmask)
{
vec3_t start_l, end_l;
vec3_t axis[3];
qboolean result;
memset (trace, 0, sizeof(trace_t));
trace->fraction = 1;
trace->allsolid = true;
trace->startsolid = false;
trace->inopen = true; //probably wrong...
VectorCopy (end, trace->endpos);
if (IS_NAN(end[0]) || IS_NAN(end[1]) || IS_NAN(end[2]))
{
Con_DPrintf("Nan in traceline\n");
return false;
}
// don't rotate non bsp ents. Too small to bother.
if (model && model->loadstate == MLS_LOADED)
{
VectorSubtract (start, origin, start_l);
VectorSubtract (end, origin, end_l);
if (angles[0] || angles[1] || angles[2])
{
AngleVectors (angles, axis[0], axis[1], axis[2]);
VectorNegate(axis[1], axis[1]);
result = model->funcs.NativeTrace (model, hulloverride, framestate, axis, start_l, end_l, mins, maxs, capsule, hitcontentsmask, trace);
}
else
{
result = model->funcs.NativeTrace (model, hulloverride, framestate, NULL, start_l, end_l, mins, maxs, capsule, hitcontentsmask, trace);
}
VectorAdd (trace->endpos, origin, trace->endpos);
}
else if (hitcontentsmask & FTECONTENTS_BODY)
{
hull_t *hull = &box_hull;
VectorSubtract (start, origin, start_l);
VectorSubtract (end, origin, end_l);
VectorCopy (end_l, trace->endpos);
result = Q1BSP_RecursiveHullCheck (hull, hull->firstclipnode, start_l, end_l, MASK_PLAYERSOLID, trace);
VectorAdd (trace->endpos, origin, trace->endpos);
if (trace->contents)
trace->contents = FTECONTENTS_BODY;
}
else
result = false;
return result;
}
/*
==================
SV_ClipMoveToEntity
Handles selection or creation of a clipping hull, and offseting (and
eventually rotation) of the end points
==================
*/
static trace_t World_ClipMoveToEntity (world_t *w, wedict_t *ent, vec3_t eorg, vec3_t eang, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int hullnum, qboolean hitmodel, qboolean capsule, unsigned int hitcontentsmask) //hullnum overrides min/max for q1 style bsps
{
trace_t trace;
model_t *model;
int mdlidx = ent->v->modelindex;
framestate_t framestate;
// get the clipping hull
if ((ent->v->solid == SOLID_BSP || ent->v->solid == SOLID_PORTAL) && mdlidx)
{
model = w->Get_CModel(w, mdlidx);
if (!model || (model->type != mod_brush && model->type != mod_heightmap))
{
// Host_Error("SOLID_BSP with non bsp model (classname: %s)", PR_GetString(w->progs, ent->v->classname));
model = NULL;
}
}
else
model = NULL;
if (!model || model->loadstate != MLS_LOADED)
{
vec3_t boxmins, boxmaxs;
model = NULL;
VectorSubtract (ent->v->mins, maxs, boxmins);
VectorSubtract (ent->v->maxs, mins, boxmaxs);
if (hitcontentsmask & ((ent->v->solid == SOLID_CORPSE && w->usesolidcorpse)?FTECONTENTS_CORPSE:FTECONTENTS_BODY))
hitcontentsmask = FTECONTENTS_CORPSE|FTECONTENTS_BODY;
else
hitcontentsmask = 0;
// if (ent->xv->geomtype == GEOMTYPE_CAPSULE && !hitmodel)
// model = World_CapsuleForBox(boxmins, boxmaxs);
// else
World_HullForBox(boxmins, boxmaxs);
}
w->Get_FrameState(w, ent, &framestate);
// trace a line through the apropriate clipping hull
if (ent->v->solid == SOLID_PORTAL)
{
//solid_portal cares only about origins and as such has no mins/max
World_TransformedTrace(model, 0, &framestate, start, end, vec3_origin, vec3_origin, capsule, &trace, eorg, eang, hitcontentsmask);
if (trace.startsolid) //portals should not block traces. this prevents infinite looping
trace.startsolid = false;
hitmodel = false;
}
else if (ent->v->solid != SOLID_BSP)
{
eang[0]*=r_meshpitch.value; //carmack made bsp models rotate wrongly.
World_TransformedTrace(model, hullnum, &framestate, start, end, mins, maxs, capsule, &trace, eorg, eang, hitcontentsmask);
eang[0]*=r_meshpitch.value;
}
else
{
if (ent->v->skin < 0)
{ //if forcedcontents is set, then ALL brushes in this model are forced to the specified contents value.
//we achive this by tracing against ALL then forcing it after.
int forcedcontents;
switch((int)ent->v->skin)
{
case Q1CONTENTS_EMPTY: forcedcontents = FTECONTENTS_EMPTY; break;
case Q1CONTENTS_SOLID: forcedcontents = FTECONTENTS_SOLID; break;
case Q1CONTENTS_WATER: forcedcontents = FTECONTENTS_WATER; break;
case Q1CONTENTS_SLIME: forcedcontents = FTECONTENTS_SLIME; break;
case Q1CONTENTS_LAVA: forcedcontents = FTECONTENTS_LAVA; break;
case Q1CONTENTS_SKY: forcedcontents = FTECONTENTS_SKY; break;
case Q1CONTENTS_LADDER: forcedcontents = FTECONTENTS_LADDER;break;
default: forcedcontents = 0; break;
}
if (hitcontentsmask & forcedcontents)
{
World_TransformedTrace(model, hullnum, &framestate, start, end, mins, maxs, capsule, &trace, eorg, eang, ~0u);
if (trace.contents)
trace.contents = forcedcontents;
}
else
{
memset (&trace, 0, sizeof(trace_t));
trace.fraction = 1;
trace.allsolid = true;
trace.startsolid = false;
trace.inopen = true; //probably wrong...
VectorCopy (end, trace.endpos);
}
}
else
World_TransformedTrace(model, hullnum, &framestate, start, end, mins, maxs, capsule, &trace, eorg, eang, hitcontentsmask);
}
// if using hitmodel, we know it hit the bounding box, so try a proper trace now.
if (hitmodel && (trace.fraction != 1 || trace.startsolid) && !model)
{
//okay, we hit the bbox
model = w->Get_CModel(w, mdlidx);
if (model && model->funcs.NativeTrace && model->loadstate == MLS_LOADED)
{
//do the second trace, using the actual mesh.
World_TransformedTrace(model, hullnum, &framestate, start, end, mins, maxs, capsule, &trace, eorg, eang, hitcontentsmask);
}
}
// did we clip the move?
if (trace.fraction < 1 || trace.startsolid || trace.allsolid)
trace.ent = ent;
return trace;
}
#define AREA_ALL 0
#define AREA_SOLID 1
#define AREA_TRIGGER 2
#ifdef USEAREAGRID
/*
================
SV_AreaEdicts
================
*/
int World_AreaEdicts (world_t *w, vec3_t mins, vec3_t maxs, wedict_t **list, int maxcount, int areatype)
{
wedict_t *check;
areagridlink_t *start, *l;
size_t count = 0;
int ming[2], maxg[2], g[2], ga;
CALCAREAGRIDBOUNDS(w, mins, maxs);
areagridsequence++;
//check ents that are just too large first
start = &w->jumboarea;
for (l=(areagridlink_t*)start->l.next ; l != start ; l = (areagridlink_t*)l->l.next)
{
check = l->ed;
// if (check->gridareasequence == areagridsequence)
// continue;
check->gridareasequence = areagridsequence;
if (areatype != AREA_ALL)
{
if (check->v->solid == SOLID_NOT)
continue; // deactivated
if ((check->v->solid == SOLID_TRIGGER) != (areatype == AREA_TRIGGER))
continue;
}
if (check->v->absmin[0] > maxs[0]
|| check->v->absmin[1] > maxs[1]
|| check->v->absmin[2] > maxs[2]
|| check->v->absmax[0] < mins[0]
|| check->v->absmax[1] < mins[1]
|| check->v->absmax[2] < mins[2])
continue; // not touching
if (count == maxcount)
{
Con_DPrintf ("World_AreaEdicts: MAXCOUNT\n");
return count;
}
list[count] = check;
count++;
}
//check the actual grid now.
for (ga = 0, g[0] = ming[0]; g[0] < maxg[0]; g[0]++)
{
for ( g[1] = ming[1]; g[1] < maxg[1]; g[1]++, ga++)
{
start = &w->gridareas[g[0] + g[1]*w->gridsize[0]];
for (l=(areagridlink_t*)start->l.next ; l != start ; l = (areagridlink_t*)l->l.next)
{
check = l->ed;
if (check->gridareasequence == areagridsequence)
continue;
check->gridareasequence = areagridsequence;
if (areatype != AREA_ALL)
{
if (check->v->solid == SOLID_NOT)
continue; // deactivated
if ((check->v->solid == SOLID_TRIGGER) != (areatype == AREA_TRIGGER))
continue;
}
if (check->v->absmin[0] > maxs[0]
|| check->v->absmin[1] > maxs[1]
|| check->v->absmin[2] > maxs[2]
|| check->v->absmax[0] < mins[0]
|| check->v->absmax[1] < mins[1]
|| check->v->absmax[2] < mins[2])
continue; // not touching
if (count == maxcount)
{
Con_Printf ("World_AreaEdicts: MAXCOUNT\n");
return count;
}
list[count] = check;
count++;
}
}
}
return count;
}
#else
float *area_mins, *area_maxs;
wedict_t **area_list;
#ifdef Q2SERVER
q2edict_t **area_q2list;
#endif
int area_count, area_maxcount;
int area_type;
static void World_AreaEdicts_r (areanode_t *node)
{
link_t *l, *next, *start;
wedict_t *check;
// touch linked edicts
start = &node->edicts;
for (l=start->next ; l != start ; l = next)
{
next = l->next;
check = EDICT_FROM_AREA(l);
if (check->v->solid == SOLID_NOT)
continue; // deactivated
/*q2 still has solid/trigger lists, emulate that here*/
if ((check->v->solid == SOLID_TRIGGER) != (area_type == AREA_TRIGGER))
continue;
if (check->v->absmin[0] > area_maxs[0]
|| check->v->absmin[1] > area_maxs[1]
|| check->v->absmin[2] > area_maxs[2]
|| check->v->absmax[0] < area_mins[0]
|| check->v->absmax[1] < area_mins[1]
|| check->v->absmax[2] < area_mins[2])
continue; // not touching
if (area_count == area_maxcount)
{
Con_Printf ("SV_AreaEdicts: MAXCOUNT\n");
return;
}
area_list[area_count] = check;
area_count++;
}
if (node->axis == -1)
return; // terminal node
// recurse down both sides
if ( area_maxs[node->axis] > node->dist )
World_AreaEdicts_r ( node->children[0] );
if ( area_mins[node->axis] < node->dist )
World_AreaEdicts_r ( node->children[1] );
}
/*
================
SV_AreaEdicts
================
*/
int World_AreaEdicts (world_t *w, vec3_t mins, vec3_t maxs, wedict_t **list, int maxcount, int areatype)
{
area_mins = mins;
area_maxs = maxs;
area_list = list;
area_count = 0;
area_maxcount = maxcount;
area_type = areatype;
World_AreaEdicts_r (w->areanodes);
return area_count;
}
#endif
#ifdef Q2SERVER
float *area_mins, *area_maxs;
q2edict_t **area_q2list;
int area_count, area_maxcount;
int area_type;
static void WorldQ2_AreaEdicts_r (areanode_t *node)
{
link_t *l, *next, *start;
q2edict_t *check;
// touch linked edicts
start = &node->edicts;
for (l=start->next ; l != start ; l = next)
{
if (!l)
{
int i;
World_ClearWorld(&sv.world, false);
check = ge->edicts;
for (i = 0; i < ge->num_edicts; i++, check = (q2edict_t *)((char *)check + ge->edict_size))
memset(&check->area, 0, sizeof(check->area));
Con_Printf ("SV_AreaEdicts: Bad links\n");
return;
}
next = l->next;
check = Q2EDICT_FROM_AREA(l);
if (check->solid == Q2SOLID_NOT)
continue; // deactivated
/*q2 still has solid/trigger lists, emulate that here*/
if ((check->solid == Q2SOLID_TRIGGER) != (area_type == AREA_TRIGGER))
continue;
if (check->absmin[0] > area_maxs[0]
|| check->absmin[1] > area_maxs[1]
|| check->absmin[2] > area_maxs[2]
|| check->absmax[0] < area_mins[0]
|| check->absmax[1] < area_mins[1]
|| check->absmax[2] < area_mins[2])
continue; // not touching
if (area_count == area_maxcount)
{
Con_Printf ("SV_AreaEdicts: MAXCOUNT\n");
return;
}
area_q2list[area_count] = check;
area_count++;
}
if (node->axis == -1)
return; // terminal node
// recurse down both sides
if ( area_maxs[node->axis] > node->dist )
WorldQ2_AreaEdicts_r ( node->children[0] );
if ( area_mins[node->axis] < node->dist )
WorldQ2_AreaEdicts_r ( node->children[1] );
}
int VARGS WorldQ2_AreaEdicts (world_t *w, vec3_t mins, vec3_t maxs, q2edict_t **list,
int maxcount, int areatype)
{
area_mins = mins;
area_maxs = maxs;
area_q2list = list;
area_count = 0;
area_maxcount = maxcount;
area_type = areatype;
WorldQ2_AreaEdicts_r (w->areanodes);
return area_count;
}
#endif
/*
================
SV_HeadnodeForEntity
Returns a headnode that can be used for testing or clipping an
object of mins/maxs size.
Offset is filled in to contain the adjustment that must be added to the
testing object's origin to get a point to use with the returned hull.
================
*/
#ifdef Q2SERVER
static model_t *WorldQ2_ModelForEntity (world_t *w, q2edict_t *ent)
{
model_t *model;
// decide which clipping hull to use, based on the size
if (ent->solid == Q2SOLID_BSP)
{ // explicit hulls in the BSP model
model = w->Get_CModel(w, ent->s.modelindex);
if (!model)
SV_Error ("Q2SOLID_BSP with a non bsp model");
if (model->loadstate == MLS_LOADED)
return model;
}
// create a temp hull from bounding box sizes
return CM_TempBoxModel (ent->mins, ent->maxs);
}
#endif
#ifdef Q2SERVER
void WorldQ2_ClipMoveToEntities (world_t *w, moveclip_t *clip )
{
int i, num;
q2edict_t *touchlist[MAX_Q2EDICTS], *touch;
trace_t trace;
model_t *model;
float *angles;
num = WorldQ2_AreaEdicts (w, clip->boxmins, clip->boxmaxs, touchlist
, MAX_Q2EDICTS, AREA_SOLID);
// be careful, it is possible to have an entity in this
// list removed before we get to it (killtriggered)
for (i=0 ; i<num ; i++)
{
touch = touchlist[i];
if (touch->solid == Q2SOLID_NOT)
continue;
if (touch == clip->q2passedict)
continue;
if (clip->trace.allsolid)
return;
if (clip->q2passedict)
{
if (touch->owner == clip->q2passedict)
continue; // don't clip against own missiles
if (clip->q2passedict->owner == touch)
continue; // don't clip against owner
}
if (touch->svflags & SVF_DEADMONSTER)
if ( !(clip->hitcontentsmask & Q2CONTENTS_DEADMONSTER))
continue;
// might intersect, so do an exact clip
model = WorldQ2_ModelForEntity (w, touch);
angles = touch->s.angles;
if (touch->solid != Q2SOLID_BSP)
angles = vec3_origin; // boxes don't rotate
if (touch->svflags & SVF_MONSTER)
World_TransformedTrace (model, 0, NULL, clip->start, clip->end, clip->mins2, clip->maxs2, false, &trace, touch->s.origin, angles, clip->hitcontentsmask);
else
World_TransformedTrace (model, 0, NULL, clip->start, clip->end, clip->mins, clip->maxs, false, &trace, touch->s.origin, angles, clip->hitcontentsmask);
if (trace.allsolid || trace.startsolid ||
trace.fraction < clip->trace.fraction)
{
trace.ent = (edict_t *)touch;
if (clip->trace.startsolid)
{
clip->trace = trace;
clip->trace.startsolid = true;
}
else
clip->trace = trace;
}
else if (trace.startsolid)
clip->trace.startsolid = true;
}
#undef ped
}
#endif
//===========================================================================
//a portal is flush with a world surface behind it.
//this causes problems. namely that we can't pass through the portal plane if the bsp behind it prevents out origin from getting through.
//so if the trace was clipped and ended infront of the portal, continue the trace to the edges of the portal cutout instead.
void World_PortalCSG(wedict_t *portal, float *trmin, float *trmax, vec3_t start, vec3_t end, trace_t *trace)
{
vec4_t planes[6]; //far, near, right, left, up, down
int plane;
vec3_t worldpos;
float bestfrac;
int hitplane;
float portalradius = portal->v->impulse;
//only run this code if we impacted on the portal's parent.
if (trace->fraction == 1 && !trace->startsolid)
return;
if (!portalradius)
return;
if (trace->startsolid)
VectorCopy(start, worldpos); //make sure we use a sane valid position.
else
VectorCopy(trace->endpos, worldpos);
//determine the csg area. normals should be facing in
AngleVectors(portal->v->angles, planes[1], planes[3], planes[5]);
VectorNegate(planes[1], planes[0]);
VectorNegate(planes[3], planes[2]);
VectorNegate(planes[5], planes[4]);
portalradius/=2;
planes[0][3] = DotProduct(portal->v->origin, planes[0]) - (4.0/32);
planes[1][3] = DotProduct(portal->v->origin, planes[1]) - (4.0/32); //an epsilon beyond the portal
planes[2][3] = DotProduct(portal->v->origin, planes[2]) - portalradius;
planes[3][3] = DotProduct(portal->v->origin, planes[3]) - portalradius;
planes[4][3] = DotProduct(portal->v->origin, planes[4]) - portalradius;
planes[5][3] = DotProduct(portal->v->origin, planes[5]) - portalradius;
//if we're actually inside the csg region
for (plane = 0; plane < 6; plane++)
{
vec3_t nearest;
float d = DotProduct(worldpos, planes[plane]);
int k;
for (k = 0; k < 3; k++)
nearest[k] = (planes[plane][k]>=0)?trmax[k]:trmin[k];
if (!plane) //front plane gets further away with side
planes[plane][3] -= DotProduct(nearest, planes[plane]);
else if (plane>1) //side planes get nearer with size
planes[plane][3] += 24;//DotProduct(nearest, planes[plane]);
if (d - planes[plane][3] >= 0)
continue; //endpos is inside
else
return; //end is already outside
}
//yup, we're inside, the trace shouldn't end where it actually did
bestfrac = 1;
hitplane = -1;
for (plane = 0; plane < 6; plane++)
{
float ds = DotProduct(start, planes[plane]) - planes[plane][3];
float de = DotProduct(end, planes[plane]) - planes[plane][3];
float frac;
if (ds >= 0 && de < 0)
{
frac = (ds) / (ds - de);
if (frac < bestfrac)
{
if (frac < 0)
frac = 0;
bestfrac = frac;
hitplane = plane;
}
}
}
trace->startsolid = trace->allsolid = false;
//if we cross the front of the portal, don't shorten the trace, that will artificially clip us
if (hitplane == 0 && trace->fraction > bestfrac)
return;
//okay, elongate to clip to the portal hole properly.
trace->fraction = bestfrac;
VectorInterpolate(start, bestfrac, end, trace->endpos);
if (hitplane >= 0)
{
VectorCopy(planes[hitplane], trace->plane.normal);
trace->plane.dist = planes[hitplane][3];
if (hitplane == 1)
trace->ent = portal;
}
}
/*
====================
SV_ClipToEverything
like SV_ClipToLinks, but doesn't use the links part. This can be used for checking triggers, solid entities, not-solid entities.
Sounds pointless, I know.
====================
*/
static void World_ClipToEverything (world_t *w, moveclip_t *clip)
{
int e;
trace_t trace;
wedict_t *touch;
for (e=1 ; e<w->num_edicts ; e++)
{
touch = (wedict_t*)EDICT_NUM_PB(w->progs, e);
if (ED_ISFREE(touch))
continue;
if (touch->v->solid == SOLID_NOT && !((int)touch->v->flags & FL_FINDABLE_NONSOLID))
continue;
if (touch->v->solid == SOLID_TRIGGER && !((int)touch->v->flags & FL_FINDABLE_NONSOLID))
continue;
if (touch == clip->passedict)
continue;
if (clip->type & MOVE_NOMONSTERS && touch->v->solid != SOLID_BSP)
continue;
if (clip->passedict)
{
if (w->usesolidcorpse)
{
// don't clip corpse against character
if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
}
if (!((int)clip->passedict->xv->dimension_hit & (int)touch->xv->dimension_solid))
continue;
}
if (clip->boxmins[0] > touch->v->absmax[0]
|| clip->boxmins[1] > touch->v->absmax[1]
|| clip->boxmins[2] > touch->v->absmax[2]
|| clip->boxmaxs[0] < touch->v->absmin[0]
|| clip->boxmaxs[1] < touch->v->absmin[1]
|| clip->boxmaxs[2] < touch->v->absmin[2] )
continue;
if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
continue; // points never interact
// might intersect, so do an exact clip
// if (clip->trace.allsolid)
// return;
if (clip->passedict)
{
if ((wedict_t*)PROG_TO_EDICT(w->progs, touch->v->owner) == clip->passedict)
continue; // don't clip against own missiles
if ((wedict_t*)PROG_TO_EDICT(w->progs, clip->passedict->v->owner) == touch)
continue; // don't clip against owner
}
if (touch->v->solid == SOLID_PORTAL)
{
//make sure we don't hit the world if we're inside the portal
World_PortalCSG(touch, clip->mins, clip->maxs, clip->start, clip->end, &clip->trace);
}
if ((int)touch->v->flags & FL_MONSTER)
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins2, clip->maxs2, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
else
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins, clip->maxs, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
if (trace.allsolid || trace.startsolid ||
trace.fraction < clip->trace.fraction)
{
if (clip->type & MOVE_ENTCHAIN)
{
touch->v->chain = EDICT_TO_PROG(w->progs, clip->trace.ent?clip->trace.ent:w->edicts);
clip->trace.ent = touch;
}
else
{
trace.ent = touch;
clip->trace = trace;
}
}
}
}
#ifdef USEAREAGRID
void World_TouchAllLinks (world_t *w, wedict_t *ent)
{
wedict_t *touchedicts[2048], *touch;
int num;
num = World_AreaEdicts(w, ent->v->absmin, ent->v->absmax, touchedicts, countof(touchedicts), AREA_TRIGGER);
while (num-- > 0)
{
touch = touchedicts[num];
//make sure nothing moved it away
if (ED_ISFREE(touch))
continue;
if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
continue;
if (touch == ent)
continue;
if (ent->v->absmin[0] > touch->v->absmax[0]
|| ent->v->absmin[1] > touch->v->absmax[1]
|| ent->v->absmin[2] > touch->v->absmax[2]
|| ent->v->absmax[0] < touch->v->absmin[0]
|| ent->v->absmax[1] < touch->v->absmin[1]
|| ent->v->absmax[2] < touch->v->absmin[2] )
continue;
if (!((int)ent->xv->dimension_solid & (int)touch->xv->dimension_hit)) //didn't change did it?...
continue;
w->Event_Touch(w, touch, ent, NULL);
if (ED_ISFREE(ent))
break;
}
}
void World_UnlinkEdict (wedict_t *ent)
{
size_t i;
for (i = 0; i < countof(ent->gridareas); i++)
{
if (!ent->gridareas[i].l.prev)
return; // not linked in anywhere
RemoveLink (&ent->gridareas[i].l);
ent->gridareas[i].l.prev = ent->gridareas[i].l.next = NULL;
}
}
static void World_ClipToLinks (world_t *w, areagridlink_t *node, moveclip_t *clip)
{
link_t *l, *next;
wedict_t *touch;
trace_t trace;
// touch linked edicts
for (l = node->l.next ; l != &node->l ; l = next)
{
next = l->next;
touch = ((areagridlink_t*)l)->ed;
if (touch->gridareasequence == areagridsequence)
continue;
touch->gridareasequence = areagridsequence;
if (touch->v->solid == SOLID_NOT)
continue;
if (touch == clip->passedict)
continue;
/*if its a trigger, we only clip against it if the flags are aligned*/
if (touch->v->solid == SOLID_TRIGGER || touch->v->solid == SOLID_LADDER)
{
if (!(clip->type & MOVE_TRIGGERS))
continue;
if (!((int)touch->v->flags & FL_FINDABLE_NONSOLID))
continue;
}
if (clip->type & MOVE_LAGGED)
{
//can't touch lagged ents - we do an explicit test for them later.
if (touch->entnum-1 < w->maxlagents)
if (w->lagents[touch->entnum-1].present)
continue;
}
if ((clip->type & MOVE_NOMONSTERS) && (touch->v->solid != SOLID_BSP && touch->v->solid != SOLID_PORTAL))
continue;
if (clip->passedict)
{
if (w->usesolidcorpse)
{
#if 1
// if (!(clip->hitcontentsmask & ((touch->v->solid == SOLID_CORPSE)?FTECONTENTS_CORPSE:FTECONTENTS_BODY)))
// continue;
#else
// don't clip corpse against character
if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
#endif
}
if (!((int)clip->passedict->xv->dimension_hit & (int)touch->xv->dimension_solid))
continue;
}
if (clip->boxmins[0] > touch->v->absmax[0]
|| clip->boxmins[1] > touch->v->absmax[1]
|| clip->boxmins[2] > touch->v->absmax[2]
|| clip->boxmaxs[0] < touch->v->absmin[0]
|| clip->boxmaxs[1] < touch->v->absmin[1]
|| clip->boxmaxs[2] < touch->v->absmin[2] )
continue;
if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
continue; // points never interact
// might intersect, so do an exact clip
// if (clip->trace.allsolid)
// return;
if (clip->passedict)
{
if ((wedict_t*)PROG_TO_EDICT(w->progs, touch->v->owner) == clip->passedict)
continue; // don't clip against own missiles
if ((wedict_t*)PROG_TO_EDICT(w->progs, clip->passedict->v->owner) == touch)
continue; // don't clip against owner
}
if (touch->v->solid == SOLID_PORTAL)
{
//make sure we don't hit the world if we're inside the portal
World_PortalCSG(touch, clip->mins, clip->maxs, clip->start, clip->end, &clip->trace);
}
if ((int)touch->v->flags & FL_MONSTER)
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins2, clip->maxs2, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
else
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins, clip->maxs, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
if (trace.fraction < clip->trace.fraction)
{
//trace traveled less, but don't forget if we started in a solid.
trace.startsolid |= clip->trace.startsolid;
trace.allsolid |= clip->trace.allsolid;
if (clip->type & MOVE_ENTCHAIN)
{
touch->v->chain = EDICT_TO_PROG(w->progs, clip->trace.ent?clip->trace.ent:w->edicts);
clip->trace.ent = touch;
}
else
{
if (clip->trace.startsolid && !trace.startsolid)
trace.ent = clip->trace.ent; //something else hit earlier, that one gets the trace entity, but not the fraction. yeah, combining traces like this was always going to be weird.
else
trace.ent = touch;
clip->trace = trace;
}
}
else if (trace.startsolid || trace.allsolid)
{
//even if the trace traveled less, we still care if it was in a solid.
clip->trace.startsolid |= trace.startsolid;
clip->trace.allsolid |= trace.allsolid;
clip->trace.contents |= trace.contents;
if (!clip->trace.ent || trace.fraction == clip->trace.fraction) //xonotic requires that second test (DP has no check at all, which would end up reporting mismatched fraction/ent results, so yuck).
{
clip->trace.ent = touch;
}
}
}
}
static void World_ClipToAllLinks (world_t *w, moveclip_t *clip)
{
int ming[2], maxg[2], g[2];
areagridsequence++;
World_ClipToLinks(w, &w->jumboarea, clip);
CALCAREAGRIDBOUNDS(w, clip->boxmins, clip->boxmaxs);
for ( g[0] = ming[0]; g[0] < maxg[0]; g[0]++)
for (g[1] = ming[1]; g[1] < maxg[1]; g[1]++)
{
World_ClipToLinks(w, &w->gridareas[g[0] + g[1]*w->gridsize[0]], clip);
}
}
#else
/*
====================
SV_ClipToLinks
Mins and maxs enclose the entire area swept by the move
====================
*/
static void World_ClipToLinks (world_t *w, areanode_t *node, moveclip_t *clip)
{
link_t *l, *next;
wedict_t *touch;
trace_t trace;
// touch linked edicts
for (l = node->edicts.next ; l != &node->edicts ; l = next)
{
next = l->next;
touch = EDICT_FROM_AREA(l);
if (touch->v->solid == SOLID_NOT)
continue;
if (touch == clip->passedict)
continue;
/*if its a trigger, we only clip against it if the flags are aligned*/
if (touch->v->solid == SOLID_TRIGGER || touch->v->solid == SOLID_LADDER)
{
if (!(clip->type & MOVE_TRIGGERS))
continue;
if (!((int)touch->v->flags & FL_FINDABLE_NONSOLID))
continue;
}
if (clip->type & MOVE_LAGGED)
{
//can't touch lagged ents - we do an explicit test for them later.
if (touch->entnum-1 < w->maxlagents)
if (w->lagents[touch->entnum-1].present)
continue;
}
if ((clip->type & MOVE_NOMONSTERS) && (touch->v->solid != SOLID_BSP && touch->v->solid != SOLID_PORTAL))
continue;
if (clip->passedict)
{
if (w->usesolidcorpse)
{
#if 1
// if (!(clip->hitcontentsmask & ((touch->v->solid == SOLID_CORPSE)?FTECONTENTS_CORPSE:FTECONTENTS_BODY)))
// continue;
#else
// don't clip corpse against character
if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
#endif
}
if (!((int)clip->passedict->xv->dimension_hit & (int)touch->xv->dimension_solid))
continue;
}
if (clip->boxmins[0] > touch->v->absmax[0]
|| clip->boxmins[1] > touch->v->absmax[1]
|| clip->boxmins[2] > touch->v->absmax[2]
|| clip->boxmaxs[0] < touch->v->absmin[0]
|| clip->boxmaxs[1] < touch->v->absmin[1]
|| clip->boxmaxs[2] < touch->v->absmin[2] )
continue;
if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
continue; // points never interact
// might intersect, so do an exact clip
// if (clip->trace.allsolid)
// return;
if (clip->passedict)
{
if ((wedict_t*)PROG_TO_EDICT(w->progs, touch->v->owner) == clip->passedict)
continue; // don't clip against own missiles
if ((wedict_t*)PROG_TO_EDICT(w->progs, clip->passedict->v->owner) == touch)
continue; // don't clip against owner
}
if (touch->v->solid == SOLID_PORTAL)
{
//make sure we don't hit the world if we're inside the portal
World_PortalCSG(touch, clip->mins, clip->maxs, clip->start, clip->end, &clip->trace);
}
if ((int)touch->v->flags & FL_MONSTER)
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins2, clip->maxs2, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
else
trace = World_ClipMoveToEntity (w, touch, touch->v->origin, touch->v->angles, clip->start, clip->mins, clip->maxs, clip->end, clip->hullnum, clip->type & MOVE_HITMODEL, clip->capsule, clip->hitcontentsmask);
if (trace.fraction < clip->trace.fraction)
{
//trace traveled less, but don't forget if we started in a solid.
trace.startsolid |= clip->trace.startsolid;
trace.allsolid |= clip->trace.allsolid;
if (clip->type & MOVE_ENTCHAIN)
{
touch->v->chain = EDICT_TO_PROG(w->progs, clip->trace.ent?clip->trace.ent:w->edicts);
clip->trace.ent = touch;
}
else
{
if (clip->trace.startsolid && !trace.startsolid)
trace.ent = clip->trace.ent; //something else hit earlier, that one gets the trace entity, but not the fraction. yeah, combining traces like this was always going to be weird.
else
trace.ent = touch;
clip->trace = trace;
}
}
else if (trace.startsolid || trace.allsolid)
{
//even if the trace traveled less, we still care if it was in a solid.
clip->trace.startsolid |= trace.startsolid;
clip->trace.allsolid |= trace.allsolid;
clip->trace.contents |= trace.contents;
if (!clip->trace.ent)
{
clip->trace.ent = touch;
}
}
}
// recurse down both sides
if (node->axis == -1)
return;
if ( clip->boxmaxs[node->axis] > node->dist )
World_ClipToLinks (w, node->children[0], clip );
if ( clip->boxmins[node->axis] < node->dist )
World_ClipToLinks (w, node->children[1], clip );
}
#endif
#ifdef HAVE_CLIENT
//The logic of this function is seriously handicapped vs the other types of trace we could be doing.
static void World_ClipToNetwork (world_t *w, moveclip_t *clip)
{
int i;
packet_entities_t *pe = cl.currentpackentities;
entity_state_t *touch;
unsigned int touchcontents;
model_t *model;
vec3_t bmins, bmaxs;
trace_t trace;
static framestate_t framestate; //meh
if ((clip->type & MOVE_ENTCHAIN) || !pe)
return;
for (i = 0; i < pe->num_entities; i++)
{
touch = &pe->entities[i];
if (touch->solidsize == ES_SOLID_BSP)
{
switch(touch->skinnum)
{
case Q1CONTENTS_LADDER: touchcontents = FTECONTENTS_LADDER; break;
case Q1CONTENTS_SKY: touchcontents = FTECONTENTS_SKY; break;
case Q1CONTENTS_LAVA: touchcontents = FTECONTENTS_LAVA; break;
case Q1CONTENTS_SLIME: touchcontents = FTECONTENTS_SLIME; break;
case Q1CONTENTS_WATER: touchcontents = FTECONTENTS_WATER; break;
default: touchcontents = ~0; break; //could be anything... :(
}
if (touch->modelindex <= 0 || touch->modelindex >= MAX_PRECACHE_MODELS)
continue; //erk
model = cl.model_precache[touch->modelindex];
VectorCopy(model->mins, bmins);
VectorCopy(model->maxs, bmaxs);
}
#if 1
else
continue; //only hit brush ents.
#else
else if (touch->solidsize == ES_SOLID_NOT)
continue;
else
{
if (clip->type & MOVE_NOMONSTERS)
continue;
touchcontents = FTECONTENTS_BODY;
model = NULL;
COM_DecodeSize(touch->solidsize, bmins, bmaxs);
}
#endif
if (!(clip->hitcontentsmask & touchcontents))
continue;
//FIXME: this doesn't handle rotations.
if ( clip->boxmins[0] > touch->origin[0]+bmaxs[0]
|| clip->boxmins[1] > touch->origin[1]+bmaxs[1]
|| clip->boxmins[2] > touch->origin[2]+bmaxs[2]
|| clip->boxmaxs[0] < touch->origin[0]+bmins[0]
|| clip->boxmaxs[1] < touch->origin[1]+bmins[1]
|| clip->boxmaxs[2] < touch->origin[2]+bmins[2] )
continue;
//lets say that ssqc ents are in dimension 0x1, as far as the csqc can see.
if (!((int)clip->passedict->xv->dimension_hit & 1))
continue;
if (!model || model->loadstate != MLS_LOADED || !model->funcs.NativeTrace)
{
model = NULL;
if (clip->hitcontentsmask & FTECONTENTS_BODY)
touchcontents = FTECONTENTS_CORPSE|FTECONTENTS_BODY;
else
touchcontents = 0;
World_HullForBox(bmins, bmaxs);
}
framestate.g[FS_REG].frame[0] = touch->frame;
framestate.g[FS_REG].lerpweight[0] = 1;
if (World_TransformedTrace(model, 0, &framestate, clip->start, clip->end, clip->mins, clip->maxs, clip->capsule, &trace, touch->origin, vec3_origin, clip->hitcontentsmask))
{
// if using hitmodel, we know it hit the bounding box, so try a proper trace now.
/*if (clip->type & MOVE_HITMODEL && (trace.fraction != 1 || trace.startsolid) && !model)
{
//okay, we hit the bbox
model = w->Get_CModel(w, mdlidx);
if (model && model->funcs.NativeTrace && model->loadstate == MLS_LOADED)
{
//do the second trace, using the actual mesh.
World_TransformedTrace(model, hullnum, &framestate, start, end, mins, maxs, capsule, &trace, eorg, vec3_origin, hitcontentsmask);
}
}*/
}
if (trace.fraction < clip->trace.fraction)
{
//trace traveled less, but don't forget if we started in a solid.
trace.startsolid |= clip->trace.startsolid;
trace.allsolid |= clip->trace.allsolid;
if (clip->trace.startsolid && !trace.startsolid)
trace.ent = clip->trace.ent; //something else hit earlier, that one gets the trace entity, but not the fraction. yeah, combining traces like this was always going to be weird.
else
{
trace.ent = w->edicts; //misreport world
clip->trace.entnum = touch->number; //with an ssqc ent number
}
clip->trace = trace;
}
else if (trace.startsolid || trace.allsolid)
{
//even if the trace traveled less, we still care if it was in a solid.
clip->trace.startsolid |= trace.startsolid;
clip->trace.allsolid |= trace.allsolid;
if (!clip->trace.ent || trace.fraction == clip->trace.fraction) //xonotic requires that second test (DP has no check at all, which would end up reporting mismatched fraction/ent results, so yuck).
{
clip->trace.contents = trace.contents;
clip->trace.ent = w->edicts; //misreport world
clip->trace.entnum = touch->number; //with an ssqc ent number
}
}
}
}
#endif
/*
==================
SV_MoveBounds
==================
*/
static void World_MoveBounds (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, vec3_t boxmins, vec3_t boxmaxs)
{
#if 0
// debug to test against everything
boxmins[0] = boxmins[1] = boxmins[2] = -9999;
boxmaxs[0] = boxmaxs[1] = boxmaxs[2] = 9999;
#else
int i;
for (i=0 ; i<3 ; i++)
{
if (end[i] > start[i])
{
boxmins[i] = start[i] + mins[i] - 1;
boxmaxs[i] = end[i] + maxs[i] + 1;
}
else
{
boxmins[i] = end[i] + mins[i] - 1;
boxmaxs[i] = start[i] + maxs[i] + 1;
}
}
#endif
}
#if !defined(CLIENTONLY)
qboolean SV_AntiKnockBack(world_t *w, client_t *client)
{
int seq = client->netchan.incoming_acknowledged; //our outgoing sequence that was last acked (in qw, this matches the last known-good input frame)
client_frame_t *frame;
edict_t *ent = client->edict;
if (client->protocol != SCP_QUAKEWORLD || !client->frameunion.frames || !ent)
return false; //FIXME: support nq protocols too
//reload player state from the journal (the input frame should already have been applied)
frame = &client->frameunion.frames[seq&UPDATE_MASK];
VectorCopy(frame->pmorigin, pmove.origin);
VectorCopy(frame->pmvelocity, pmove.velocity);
pmove.pm_type = frame->pmtype;
pmove.onground = true;//FIXME
pmove.jump_held = frame->pmjumpheld;
pmove.waterjumptime = frame->pmwaterjumptime;
pmove.onladder = frame->pmonladder;
//stuff not regenerated properly, shouldn't really be changing much or not very significant.
pmove.world = w;
VectorCopy(ent->v->mins, pmove.player_mins);
VectorCopy(ent->v->maxs, pmove.player_maxs);
pmove.capsule = (ent->xv->geomtype == GEOMTYPE_CAPSULE);
if (ent->xv->gravitydir[2] || ent->xv->gravitydir[1] || ent->xv->gravitydir[0])
VectorCopy(ent->xv->gravitydir, pmove.gravitydir);
else
VectorCopy(w->g.defaultgravitydir, pmove.gravitydir);
//FIXME
VectorCopy(ent->v->oldorigin, pmove.safeorigin);
pmove.safeorigin_known = false;
pmove.jump_msec = 0;
VectorClear(pmove.basevelocity);
//and apply each more recent frame
while (++seq <= client->netchan.incoming_sequence)
{
if (frame->sequence != seq)
continue; //FIXME: lost
pmove.sequence = seq;
pmove.cmd = frame->cmd;
// pmove.angles;
// pmove.numphysent/physents;
PM_PlayerMove(sv.gamespeed);
}
return true;
}
#endif
/*
==================
SV_Move
==================
*/
trace_t World_Move (world_t *w, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, wedict_t *passedict)
{
moveclip_t clip;
int i;
int hullnum;
memset ( &clip, 0, sizeof ( moveclip_t ) );
if (passedict && passedict->xv->hull && !(type & MOVE_IGNOREHULL))
hullnum = passedict->xv->hull;
#ifdef CLIENTONLY
else
hullnum = 0;
#else
else if (sv_compatiblehulls.value)
hullnum = 0;
else
{
int diff;
int best;
hullnum = 0;
best = 8192;
//x/y pos/neg are assumed to be the same magnitute.
//z pos/height are assumed to be different from all the others.
for (i = 0; i < MAX_MAP_HULLSM; i++)
{
if (!w->worldmodel->hulls[i].available)
continue;
#define sq(x) ((x)*(x))
diff = sq(w->worldmodel->hulls[i].clip_maxs[2] - maxs[2]) +
sq(w->worldmodel->hulls[i].clip_mins[2] - mins[2]) +
sq(w->worldmodel->hulls[i].clip_maxs[1] - maxs[1]) +
sq(w->worldmodel->hulls[i].clip_mins[0] - mins[0]);
if (diff < best)
{
best = diff;
hullnum=i;
}
}
hullnum++;
}
#endif
#if !defined(CLIENTONLY)
//figure out where the firing player was, and re-run their input frames to calculate their position without any velocity/knockback changes.
//then update the start position to compensate.
if ((clip.type & MOVE_LAGGED) && w == &sv.world && passedict->entnum && passedict->entnum <= sv.allocated_client_slots && sv_antilag.ival==3)
{
vec3_t nudge;
if (SV_AntiKnockBack(w, &svs.clients[passedict->entnum-1]))
{
VectorSubtract(pmove.origin, passedict->v->origin, nudge);
VectorAdd(start, nudge, start);
VectorAdd(end, nudge, end);
}
}
#endif
if (passedict->xv->hitcontentsmaski)
clip.hitcontentsmask = passedict->xv->hitcontentsmaski;
#ifndef NOLEGACY
else if (passedict->xv->dphitcontentsmask)
{
unsigned int nm=0, fl = passedict->xv->dphitcontentsmask;
if (fl & DPCONTENTS_SOLID)
nm |= FTECONTENTS_SOLID;
if (fl & DPCONTENTS_WATER)
nm |= FTECONTENTS_WATER;
if (fl & DPCONTENTS_SLIME)
nm |= FTECONTENTS_SLIME;
if (fl & DPCONTENTS_LAVA)
nm |= FTECONTENTS_LAVA;
if (fl & DPCONTENTS_SKY)
nm |= FTECONTENTS_SKY;
if (fl & DPCONTENTS_BODY)
nm |= FTECONTENTS_BODY;
if (fl & DPCONTENTS_CORPSE)
nm |= FTECONTENTS_CORPSE;
if (fl & DPCONTENTS_NODROP)
nm |= Q3CONTENTS_NODROP;
if (fl & DPCONTENTS_PLAYERCLIP)
nm |= FTECONTENTS_PLAYERCLIP;
if (fl & DPCONTENTS_MONSTERCLIP)
nm |= FTECONTENTS_MONSTERCLIP;
if (fl & DPCONTENTS_DONOTENTER)
nm |= Q3CONTENTS_DONOTENTER;
if (fl & DPCONTENTS_BOTCLIP)
nm |= Q3CONTENTS_BOTCLIP;
// if (fl & DPCONTENTS_OPAQUE)
// nm |= DPCONTENTS_OPAQUE;
clip.hitcontentsmask = nm;
}
#endif
/*#ifndef NOLEGACY
else if (passedict->xv->hitcontentsmask)
clip.hitcontentsmask = passedict->xv->hitcontentsmask;
#endif*/
else if (passedict->v->solid == SOLID_SLIDEBOX)
{
if ((int)passedict->v->flags & FL_MONSTER)
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY | FTECONTENTS_MONSTERCLIP; /*solid only to world*/
else if (maxs[0] - mins[0] > 0)
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY | FTECONTENTS_PLAYERCLIP; /*impacts playerclip*/
else
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY; //slidebox passes through corpses
}
else if (passedict->v->solid == SOLID_CORPSE)
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY; //corpses ignore corpses
else if (passedict->v->solid == SOLID_TRIGGER)
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY; //triggers ignore corpses too, apparently
else
clip.hitcontentsmask = FTECONTENTS_SOLID|Q2CONTENTS_WINDOW | FTECONTENTS_BODY | FTECONTENTS_CORPSE; //regular projectiles.
clip.capsule = (passedict->xv->geomtype == GEOMTYPE_CAPSULE);
if (type & MOVE_OTHERONLY)
{
wedict_t *other = WEDICT_NUM_UB(w->progs, *w->g.other);
return World_ClipMoveToEntity (w, other, other->v->origin, other->v->angles, start, mins, maxs, end, hullnum, type & MOVE_HITMODEL, clip.capsule, clip.hitcontentsmask);
}
#ifndef NOLEGACY
if ((type&MOVE_WORLDONLY) == MOVE_WORLDONLY)
{ //for compat with DP
wedict_t *other = w->edicts;
return World_ClipMoveToEntity (w, other, other->v->origin, other->v->angles, start, mins, maxs, end, hullnum, type & MOVE_HITMODEL, clip.capsule, clip.hitcontentsmask);
}
#endif
// clip to world
clip.trace = World_ClipMoveToEntity (w, w->edicts, w->edicts->v->origin, w->edicts->v->angles, start, mins, maxs, end, hullnum, false, clip.capsule, clip.hitcontentsmask);
clip.start = start;
clip.end = end;
clip.mins = mins;
clip.maxs = maxs;
clip.type = type;
clip.passedict = passedict;
clip.hullnum = 0;//hullnum; //BUG: hexen2's SV_ClipMoveToEntity's move_ent argument is set inconsistantly. This has the effect that the SOLID_BSP's .hull field is used instead of the SOLID_BBOX entity. We can't fix this because hexen2 depends upon it - this is the 'tibet5' bug.
#ifdef Q2SERVER
clip.q2passedict = NULL;
#endif
if (type & MOVE_MISSILE)
{
if (type & MOVE_NOMONSTERS)
return clip.trace; //not sure why you'd really want this, but for the sake of dp compat...
for (i=0 ; i<3 ; i++)
{
clip.mins2[i] = -15;
clip.maxs2[i] = 15;
}
}
else
{
VectorCopy (mins, clip.mins2);
VectorCopy (maxs, clip.maxs2);
}
// create the bounding box of the entire move
World_MoveBounds (start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );
// clip to entities
if (clip.type & MOVE_EVERYTHING)
World_ClipToEverything (w, &clip);
else
{
if (clip.type & MOVE_LAGGED)
{
clip.type &= ~MOVE_LAGGED;
#ifndef CLIENTONLY
if (w == &sv.world)
{
if (passedict->entnum && passedict->entnum <= sv.allocated_client_slots)
{
clip.type |= MOVE_LAGGED;
w->lagents = svs.clients[passedict->entnum-1].laggedents;
w->maxlagents = svs.clients[passedict->entnum-1].laggedents_count;
w->lagentsfrac = svs.clients[passedict->entnum-1].laggedents_frac;
w->lagentstime = svs.clients[passedict->entnum-1].laggedents_time;
}
else if (passedict->v->owner)
{
if (passedict->v->owner && passedict->v->owner <= sv.allocated_client_slots)
{
clip.type |= MOVE_LAGGED;
w->lagents = svs.clients[passedict->v->owner-1].laggedents;
w->maxlagents = svs.clients[passedict->v->owner-1].laggedents_count;
w->lagentsfrac = svs.clients[passedict->v->owner-1].laggedents_frac;
w->lagentstime = svs.clients[passedict->entnum-1].laggedents_time;
}
}
}
#endif
}
if (clip.type & MOVE_LAGGED)
{
trace_t trace;
wedict_t *touch;
vec3_t lp, la;
int j;
#ifdef USEAREAGRID
World_ClipToAllLinks (w, &clip);
#else
World_ClipToLinks (w, w->areanodes, &clip);
#endif
for (i = 0; i < w->maxlagents; i++)
{
if (!w->lagents[i].present)
continue;
if (clip.trace.allsolid)
break;
touch = (wedict_t*)EDICT_NUM_PB(w->progs, i+1);
if (touch->v->solid == SOLID_NOT)
continue;
if (touch == clip.passedict)
continue;
if (touch->v->solid == SOLID_TRIGGER || touch->v->solid == SOLID_LADDER)
{
if (!(clip.type & MOVE_TRIGGERS))
continue;
if (!((int)touch->v->flags & FL_FINDABLE_NONSOLID))
continue;
}
if (clip.type & MOVE_NOMONSTERS && touch->v->solid != SOLID_BSP)
continue;
if (clip.passedict)
{
if (w->usesolidcorpse)
{
// don't clip corpse against character
if (clip.passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip.passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
}
if (!((int)clip.passedict->xv->dimension_hit & (int)touch->xv->dimension_solid))
continue;
}
VectorInterpolate(touch->v->origin, w->lagentsfrac, w->lagents[i].origin, lp);
//I hate working with angles
VectorSubtract(w->lagents[i].angles, touch->v->angles, la);
for (j = 0; j < 3; j++)
{
la[j] = (360.0/65536) * ((int)(la[j]*(65536/360.0)) & 65535);
if (la[j]<-180)
la[j] += 360;
if (la[j]>180)
la[j] -= 360;
}
VectorMA(touch->v->angles, 1, la, la);
if (clip.boxmins[0] > lp[0]+touch->v->maxs[0]
|| clip.boxmins[1] > lp[1]+touch->v->maxs[1]
|| clip.boxmins[2] > lp[2]+touch->v->maxs[2]
|| clip.boxmaxs[0] < lp[0]+touch->v->mins[0]
|| clip.boxmaxs[1] < lp[1]+touch->v->mins[1]
|| clip.boxmaxs[2] < lp[2]+touch->v->mins[2] )
continue;
if (clip.passedict && clip.passedict->v->size[0] && !touch->v->size[0])
continue; // points never interact
if (clip.passedict)
{
if ((wedict_t*)PROG_TO_EDICT(w->progs, touch->v->owner) == clip.passedict)
continue; // don't clip against own missiles
if ((wedict_t*)PROG_TO_EDICT(w->progs, clip.passedict->v->owner) == touch)
continue; // don't clip against owner
}
if ((clip.type & MOVE_HITMODEL) && w->Event_Backdate)
{
w->Event_Backdate(w, touch, w->lagentstime);
trace = World_ClipMoveToEntity (w, touch, lp, la, clip.start, clip.mins, clip.maxs, clip.end, clip.hullnum, clip.type & MOVE_HITMODEL, clip.capsule, clip.hitcontentsmask);
}
else
trace = World_ClipMoveToEntity (w, touch, lp, la, clip.start, clip.mins, clip.maxs, clip.end, clip.hullnum, clip.type & MOVE_HITMODEL, clip.capsule, clip.hitcontentsmask);
if (trace.allsolid || trace.startsolid || trace.fraction < clip.trace.fraction)
{
if (clip.type & MOVE_ENTCHAIN)
{
touch->v->chain = EDICT_TO_PROG(w->progs, clip.trace.ent?clip.trace.ent:w->edicts);
clip.trace.ent = touch;
}
else
{
trace.ent = touch;
clip.trace = trace;
}
}
}
}
/*else if (w->rbe_hasphysicsents && passedict->rbe.body.body)
{
w->rbe->Trace(w, clip.passedict, clip.start, clip.end, &clip.trace);
}*/
else
{
#ifdef USEAREAGRID
World_ClipToAllLinks (w, &clip );
#else
World_ClipToLinks (w, w->areanodes, &clip );
#endif
}
World_ClipToLinks(w, &w->portallist, &clip);
}
#ifdef HAVE_CLIENT
{
extern world_t csqc_world;
if (w == &csqc_world)
World_ClipToNetwork(w, &clip);
}
#endif
// if (clip.trace.startsolid)
// clip.trace.fraction = 0;
// if (!clip.trace.ent)
// return clip.trace;
return clip.trace;
}
#ifdef Q2SERVER
trace_t WorldQ2_Move (world_t *w, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int hitcontentsmask, q2edict_t *passedict)
{
moveclip_t clip;
memset ( &clip, 0, sizeof ( moveclip_t ) );
// clip to world
w->worldmodel->funcs.NativeTrace(w->worldmodel, 0, NULLFRAMESTATE, NULL, start, end, mins, maxs, false, hitcontentsmask, &clip.trace);
clip.trace.ent = ge->edicts;
if (clip.trace.fraction == 0)
return clip.trace;
clip.start = start;
clip.end = end;
clip.mins = mins;
clip.maxs = maxs;
clip.type = MOVE_NORMAL;
clip.hitcontentsmask = hitcontentsmask;
clip.passedict = NULL;
clip.q2passedict = passedict;
VectorCopy (mins, clip.mins2);
VectorCopy (maxs, clip.maxs2);
// create the bounding box of the entire move
//FIXME: should we use clip.trace.endpos here?
World_MoveBounds ( start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs );
// clip to entities
WorldQ2_ClipMoveToEntities(w, &clip);
return clip.trace;
}
#endif
static void (QDECL *world_current_physics_engine)(world_t*world);
qboolean QDECL World_RegisterPhysicsEngine(const char *enginename, void(QDECL*startupfunc)(world_t*world))
{
if (world_current_physics_engine)
return false; //no thanks, we already have one.
world_current_physics_engine = startupfunc;
return true;
}
void World_RBE_Shutdown(world_t *world)
{
#ifdef USERBE
unsigned int u;
wedict_t *ed;
if (!world->rbe)
return;
if (world->progs)
{
for (u = 0; u < world->num_edicts; u++)
{
ed = WEDICT_NUM_PB(world->progs, u);
world->rbe->RemoveJointFromEntity(world, ed);
world->rbe->RemoveFromEntity(world, ed);
}
}
world->rbe->End(world);
world->rbe = NULL;
#endif
}
void QDECL World_UnregisterPhysicsEngine(const char *enginename)
{
#ifdef RAGDOLL
rag_uninstanciateall();
#endif
#if defined(CSQC_DAT) && !defined(SERVERONLY)
{
extern world_t csqc_world;
World_RBE_Shutdown(&csqc_world);
}
#endif
#if !defined(CLIENTONLY)
World_RBE_Shutdown(&sv.world);
#endif
world_current_physics_engine = NULL;
}
void World_RBE_Start(world_t *world)
{
if (world_current_physics_engine)
{
if (world->worldmodel)
world_current_physics_engine(world);
}
}
void World_Destroy(world_t *world)
{
World_RBE_Shutdown(world);
#ifdef USEAREAGRID
Z_Free(world->gridareas);
#else
Z_Free(world->areanodes);
world->areanodes = NULL;
world->areanodedepth = 0;
#endif
memset(world, 0, sizeof(*world));
}
#ifdef USERBE
static qboolean GenerateCollisionMesh_BSP(world_t *world, model_t *mod, wedict_t *ed, vec3_t geomcenter)
{
unsigned int sno;
msurface_t *surf;
mesh_t *mesh;
unsigned int numverts;
unsigned int numindexes,i;
int *ptr_elements;
float *ptr_verts;
numverts = 0;
numindexes = 0;
for (sno = 0; sno < mod->nummodelsurfaces; sno++)
{
surf = &mod->surfaces[sno+mod->firstmodelsurface];
if (surf->flags & (SURF_DRAWSKY|SURF_DRAWTURB))
continue;
if (surf->mesh)
{
mesh = surf->mesh;
numverts += mesh->numvertexes;
numindexes += mesh->numindexes;
}
else
{
numverts += surf->numedges;
numindexes += (surf->numedges-2) * 3;
}
}
if (!numindexes)
{
Con_DPrintf("entity %i (classname %s) has no geometry\n", NUM_FOR_EDICT(world->progs, (edict_t*)ed), PR_GetString(world->progs, ed->v->classname));
return false;
}
ptr_elements = (int*)BZ_Malloc(numindexes*sizeof(*ptr_elements));
ptr_verts = (float*)BZ_Malloc(numverts*sizeof(vec3_t));
numverts = 0;
numindexes = 0;
for (sno = 0; sno < mod->nummodelsurfaces; sno++)
{
surf = &mod->surfaces[sno+mod->firstmodelsurface];
if (surf->flags & (SURF_DRAWSKY|SURF_DRAWTURB))
continue;
if (surf->mesh)
{
mesh = surf->mesh;
for (i = 0; i < mesh->numvertexes; i++)
VectorSubtract(mesh->xyz_array[i], geomcenter, (ptr_verts + 3*(numverts+i)));
for (i = 0; i < mesh->numindexes; i+=3)
{
//flip the triangles as we go
ptr_elements[numindexes+i+0] = numverts+mesh->indexes[i+2];
ptr_elements[numindexes+i+1] = numverts+mesh->indexes[i+1];
ptr_elements[numindexes+i+2] = numverts+mesh->indexes[i+0];
}
numverts += mesh->numvertexes;
numindexes += i;
}
else
{
float *vec;
medge_t *edge;
int lindex;
for (i = 0; i < surf->numedges; i++)
{
lindex = mod->surfedges[surf->firstedge + i];
if (lindex > 0)
{
edge = &mod->edges[lindex];
vec = mod->vertexes[edge->v[0]].position;
}
else
{
edge = &mod->edges[-lindex];
vec = mod->vertexes[edge->v[1]].position;
}
VectorSubtract(vec, geomcenter, (ptr_verts + 3*(numverts+i)));
}
for (i = 2; i < surf->numedges; i++)
{
//quake is backwards, not ode
ptr_elements[numindexes++] = numverts+i;
ptr_elements[numindexes++] = numverts+i-1;
ptr_elements[numindexes++] = numverts;
}
numverts += surf->numedges;
}
}
ed->rbe.element3i = ptr_elements;
ed->rbe.vertex3f = ptr_verts;
ed->rbe.numvertices = numverts;
ed->rbe.numtriangles = numindexes/3;
return true;
}
#include "com_mesh.h"
static qboolean GenerateCollisionMesh_Alias(world_t *world, model_t *mod, wedict_t *ed, vec3_t geomcenter)
{
mesh_t mesh;
unsigned int numverts;
unsigned int numindexes,i;
galiasinfo_t *inf;
unsigned int surfnum = 0;
entity_t re;
int *ptr_elements;
float *ptr_verts;
numverts = 0;
numindexes = 0;
//fill in the parts of the entity_t that Alias_GAliasBuildMesh needs.
world->Get_FrameState(world, ed, &re.framestate);
re.fatness = ed->xv->fatness;
re.model = mod;
inf = (galiasinfo_t*)Mod_Extradata (mod);
while(inf)
{
numverts += inf->numverts;
numindexes += inf->numindexes;
inf = inf->nextsurf;
}
if (!numindexes)
{
Con_DPrintf("entity %i (classname %s) has no geometry\n", NUM_FOR_EDICT(world->progs, (edict_t*)ed), PR_GetString(world->progs, ed->v->classname));
return false;
}
ptr_elements = (int*)BZ_Malloc(numindexes*sizeof(*ptr_elements));
ptr_verts = (float*)BZ_Malloc(numverts*sizeof(vec3_t));
numverts = 0;
numindexes = 0;
inf = (galiasinfo_t*)Mod_Extradata (mod);
while(inf)
{
Alias_GAliasBuildMesh(&mesh, NULL, inf, surfnum++, &re, false);
for (i = 0; i < mesh.numvertexes; i++)
VectorSubtract(mesh.xyz_array[i], geomcenter, (ptr_verts + 3*(numverts+i)));
for (i = 0; i < mesh.numindexes; i+=3)
{
//flip the triangles as we go
ptr_elements[numindexes+i+0] = numverts+mesh.indexes[i+2];
ptr_elements[numindexes+i+1] = numverts+mesh.indexes[i+1];
ptr_elements[numindexes+i+2] = numverts+mesh.indexes[i+0];
}
numverts += inf->numverts;
numindexes += inf->numindexes;
inf = inf->nextsurf;
}
Alias_FlushCache(); //it got built using an entity on the stack, make sure other stuff doesn't get hurt.
ed->rbe.element3i = ptr_elements;
ed->rbe.vertex3f = ptr_verts;
ed->rbe.numvertices = numverts;
ed->rbe.numtriangles = numindexes/3;
return true;
}
//Bullet has a fit if we have any degenerate triangles, so make sure we can determine some surface normal
static void CollisionMesh_CleanupMesh(wedict_t *ed)
{
float *v1, *v2, *v3;
vec3_t d1, d2, cr;
int in, out;
for (in = 0, out = 0; in < ed->rbe.numtriangles*3; in+=3)
{
v1 = &ed->rbe.vertex3f[ed->rbe.element3i[in+0]*3];
v2 = &ed->rbe.vertex3f[ed->rbe.element3i[in+1]*3];
v3 = &ed->rbe.vertex3f[ed->rbe.element3i[in+2]*3];
VectorSubtract(v3, v1, d1);
VectorSubtract(v2, v1, d2);
CrossProduct(d1, d2, cr);
if (DotProduct(cr,cr) == 0)
continue;
ed->rbe.element3i[out+0] = ed->rbe.element3i[in+0];
ed->rbe.element3i[out+1] = ed->rbe.element3i[in+1];
ed->rbe.element3i[out+2] = ed->rbe.element3i[in+2];
out+=3;
}
ed->rbe.numtriangles = out/3;
}
qboolean QDECL World_GenerateCollisionMesh(world_t *world, model_t *mod, wedict_t *ed, vec3_t geomcenter)
{
qboolean result;
switch(mod->type)
{
case mod_brush:
result = GenerateCollisionMesh_BSP(world, mod, ed, geomcenter);
break;
case mod_alias:
result = GenerateCollisionMesh_Alias(world, mod, ed, geomcenter);
break;
case mod_heightmap:
case mod_halflife:
case mod_sprite:
case mod_dummy:
default:
return false; //panic!
}
if (result)
{
CollisionMesh_CleanupMesh(ed);
if (ed->rbe.numtriangles > 0)
return true;
}
return false;
}
void QDECL World_ReleaseCollisionMesh(wedict_t *ed)
{
BZ_Free(ed->rbe.element3i);
ed->rbe.element3i = NULL;
BZ_Free(ed->rbe.vertex3f);
ed->rbe.vertex3f = NULL;
ed->rbe.numvertices = 0;
ed->rbe.numtriangles = 0;
}
#endif
#endif
View git blame Copy permalink