got rid of leafnums array in edict structure for pvs checking, pvs is now checked...

changed an SV_Move call to use the proper MOVE_ define (no behavior change, only cleanup)

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@978 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/progs.h b/progs.h
index 699d84b7f2322ac9ace7cb9178ce0ac169f749dc..a77faafe8f0a60aa4cc506ce3ebb79dcfa1923c1 100644 (file)
--- a/progs.h
+++ b/progs.h
@@ -43,9 +43,6 @@ typedef struct edict_s
        qboolean        free;
        link_t          area;
 
-       int                     num_leafs;
-       short           leafnums[MAX_ENT_LEAFS];
-
        entity_state_t  baseline;
        entity_state_t  deltabaseline; // LordHavoc: previous frame
 

diff --git a/sv_main.c b/sv_main.c
index 2c82c63cedb27727bc439e1e590eeb59fdee7764..aad188abc770d59a481498363e863528797e2291 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -21,6 +21,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
+cvar_t sv_pvscheckentities = {0, "sv_pvscheckentities", "1"};
 cvar_t sv_vischeckentities = {0, "sv_vischeckentities", "1"};
 cvar_t sv_reportvischeckentities = {0, "sv_reportvischeckentities", "0"};
 int sv_vischeckentitycullcount = 0;
@@ -53,6 +54,7 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_nostep);
        Cvar_RegisterVariable (&sv_predict);
        Cvar_RegisterVariable (&sv_deltacompress);
+       Cvar_RegisterVariable (&sv_pvscheckentities);
        Cvar_RegisterVariable (&sv_vischeckentities);
        Cvar_RegisterVariable (&sv_reportvischeckentities);
 
@@ -451,6 +453,40 @@ byte *SV_FatPVS (vec3_t org)
 //=============================================================================
 
 
+int SV_BoxTouchingPVS (byte *pvs, vec3_t mins, vec3_t maxs, mnode_t *node)
+{
+       int leafnum;
+loc0:
+       if (node->contents < 0)
+       {
+               // leaf
+               if (node->contents == CONTENTS_SOLID)
+                       return false;
+               leafnum = (mleaf_t *)node - sv.worldmodel->leafs - 1;
+               return pvs[leafnum >> 3] & (1 << (leafnum & 7));
+       }
+
+       // node - recurse down the BSP tree
+       switch (BOX_ON_PLANE_SIDE(mins, maxs, node->plane))
+       {
+       case 1: // front
+               node = node->children[0];
+               goto loc0;
+       case 2: // back
+               node = node->children[1];
+               goto loc0;
+       default: // crossing
+               if (node->children[0]->contents != CONTENTS_SOLID)
+                       if (SV_BoxTouchingPVS (pvs, mins, maxs, node->children[0]))
+                               return true;
+               node = node->children[1];
+               goto loc0;
+       }
+       // never reached
+       return false;
+}
+
+
 /*
 =============
 SV_WriteEntitiesToClient
@@ -466,18 +502,17 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
        edict_t *ent;
        eval_t  *val;
        entity_state_t *baseline; // LordHavoc: delta or startup baseline
+       trace_t trace;
 
 // find the client's PVS
        VectorAdd (clent->v.origin, clent->v.view_ofs, org);
        pvs = SV_FatPVS (org);
        /*
-       if (dpprotocol)
-       {
-               MSG_WriteByte(msg, svc_playerposition);
-               MSG_WriteFloat(msg, org[0]);
-               MSG_WriteFloat(msg, org[1]);
-               MSG_WriteFloat(msg, org[2]);
-       }
+       // dp protocol
+       MSG_WriteByte(msg, svc_playerposition);
+       MSG_WriteFloat(msg, org[0]);
+       MSG_WriteFloat(msg, org[1]);
+       MSG_WriteFloat(msg, org[2]);
        */
 
        clentnum = EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
@@ -510,36 +545,112 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
                                        continue;
                                if ((val = GETEDICTFIELDVALUE(ent, eval_drawonlytoclient)) && val->edict && val->edict != clentnum)
                                        continue;
-                               // ignore if not touching a PV leaf
-                               for (i = 0;i < ent->num_leafs;i++)
-                                       if (pvs[ent->leafnums[i] >> 3] & (1 << (ent->leafnums[i]&7) ))
-                                               break;
+                       }
+               }
 
-                               if (i == ent->num_leafs)
-                               {
-                                       // not visible
-                                       continue;
-                               }
+               glowsize = 0;
 
-                               VectorAdd(ent->v.mins, ent->v.origin, entmins);
-                               VectorAdd(ent->v.maxs, ent->v.origin, entmaxs);
-                               entmins[0] -= 1.0f;entmins[1] -= 1.0f;entmins[2] -= 1.0f;
-                               entmaxs[0] += 1.0f;entmaxs[1] += 1.0f;entmaxs[2] += 1.0f;
-                               if (!Portal_CheckBox(sv.worldmodel, org, entmins, entmaxs))
-                               {
-                                       sv_vischeckentitycullcount++;
+               if ((val = GETEDICTFIELDVALUE(ent, eval_glow_size)))
+                       glowsize = (int) val->_float >> 2;
+               if (glowsize > 255) glowsize = 255;
+               if (glowsize < 0) glowsize = 0;
+
+               if ((val = GETEDICTFIELDVALUE(ent, eval_glow_trail)))
+               if (val->_float != 0)
+                       bits |= U_GLOWTRAIL;
+
+               if (ent->v.modelindex == 0 || pr_strings[ent->v.model] == 0) // no model
+                       if (ent != clent) // LordHavoc: always send player
+                               if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
                                        continue;
-                               }
+
+               if (ent->v.movetype == MOVETYPE_STEP && ((int) ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) // monsters have smoothed walking/flying/swimming movement
+               {
+                       if (!ent->steplerptime || ent->steplerptime > sv.time) // when the level just started...
+                       {
+                               ent->steplerptime = sv.time;
+                               VectorCopy(ent->v.origin, ent->stepoldorigin);
+                               VectorCopy(ent->v.angles, ent->stepoldangles);
+                               VectorCopy(ent->v.origin, ent->steporigin);
+                               VectorCopy(ent->v.angles, ent->stepangles);
+                       }
+                       VectorSubtract(ent->v.origin, ent->steporigin, origin);
+                       VectorSubtract(ent->v.angles, ent->stepangles, angles);
+                       if (DotProduct(origin, origin) >= 0.125 || DotProduct(angles, angles) >= 1.4)
+                       {
+                               // update lerp positions
+                               ent->steplerptime = sv.time;
+                               VectorCopy(ent->steporigin, ent->stepoldorigin);
+                               VectorCopy(ent->stepangles, ent->stepoldangles);
+                               VectorCopy(ent->v.origin, ent->steporigin);
+                               VectorCopy(ent->v.angles, ent->stepangles);
+                       }
+                       movelerp = (sv.time - ent->steplerptime) * 10.0;
+                       if (movelerp > 1) movelerp = 1;
+                       moveilerp = 1 - movelerp;
+                       origin[0] = ent->stepoldorigin[0] * moveilerp + ent->steporigin[0] * movelerp;
+                       origin[1] = ent->stepoldorigin[1] * moveilerp + ent->steporigin[1] * movelerp;
+                       origin[2] = ent->stepoldorigin[2] * moveilerp + ent->steporigin[2] * movelerp;
+                       // choose shortest rotate (to avoid 'spin around' situations)
+                       VectorSubtract(ent->stepangles, ent->stepoldangles, angles);
+                       if (angles[0] < -180) angles[0] += 360;if (angles[0] >= 180) angles[0] -= 360;
+                       if (angles[1] < -180) angles[1] += 360;if (angles[1] >= 180) angles[1] -= 360;
+                       if (angles[2] < -180) angles[2] += 360;if (angles[2] >= 180) angles[2] -= 360;
+                       angles[0] = angles[0] * movelerp + ent->stepoldangles[0];
+                       angles[1] = angles[1] * movelerp + ent->stepoldangles[1];
+                       angles[2] = angles[2] * movelerp + ent->stepoldangles[2];
+                       //VectorMA(origin, host_client->latency, ent->v.velocity, origin);
+               }
+               else // copy as they are
+               {
+                       VectorCopy(ent->v.angles, angles);
+                       if (DotProduct(ent->v.velocity, ent->v.velocity) >= 1.0f)
+                       {
+                               VectorMA(ent->v.origin, host_client->latency, ent->v.velocity, origin);
+                               // LordHavoc: trace predicted movement to avoid putting things in walls
+                               trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, origin, MOVE_NORMAL, ent);
+                               VectorCopy(trace.endpos, origin);
+                       }
+                       else
+                       {
+                               VectorCopy(ent->v.origin, origin);              
+                       }
+                       if (ent->v.movetype == MOVETYPE_STEP) // monster, but airborn, update lerp info
+                       {
+                               // update lerp positions
+                               ent->steplerptime = sv.time;
+                               VectorCopy(ent->v.origin, ent->stepoldorigin);
+                               VectorCopy(ent->v.angles, ent->stepoldangles);
+                               VectorCopy(ent->v.origin, ent->steporigin);
+                               VectorCopy(ent->v.angles, ent->stepangles);
                        }
                }
 
-               if ((val = GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)) && val->edict == clentnum)
-                       bits = bits | U_EXTERIORMODEL;
+               // ent has survived every check so far, check if it is visible
+               if (ent != clent && ((bits & U_VIEWMODEL) == 0))
+               {
+                       // use the predicted origin
+                       entmins[0] = ent->v.mins[0] + origin[0] - 1.0f;
+                       entmins[1] = ent->v.mins[1] + origin[1] - 1.0f;
+                       entmins[2] = ent->v.mins[2] + origin[2] - 1.0f;
+                       entmaxs[0] = ent->v.maxs[0] + origin[0] + 1.0f;
+                       entmaxs[1] = ent->v.maxs[1] + origin[1] + 1.0f;
+                       entmaxs[2] = ent->v.maxs[2] + origin[2] + 1.0f;
+
+                       // if not touching a visible leaf
+                       if (sv_pvscheckentities.value && !SV_BoxTouchingPVS(pvs, entmins, entmaxs, sv.worldmodel->nodes))
+                               continue;
+
+                       // or not visible through the portals
+                       if (sv_vischeckentities.value && !Portal_CheckBox(sv.worldmodel, org, entmins, entmaxs))
+                       {
+                               sv_vischeckentitycullcount++;
+                               continue;
+                       }
+               }
 
-               // don't send if flagged for NODRAW and there are no effects
                alpha = 255;
                scale = 16;
-               glowsize = 0;
                glowcolor = 254;
                colormod = 255;
                effects = ent->v.effects;
@@ -557,20 +668,11 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
                        alpha = 255;
                alpha = bound(0, alpha, 255);
 
-               if ((val = GETEDICTFIELDVALUE(ent, eval_glow_size)))
-                       glowsize = (int) val->_float >> 2;
-               if (glowsize > 255) glowsize = 255;
-               if (glowsize < 0) glowsize = 0;
-
                if ((val = GETEDICTFIELDVALUE(ent, eval_scale)))
                if ((scale = (int) (val->_float * 16.0)) == 0) scale = 16;
                if (scale < 0) scale = 0;
                if (scale > 255) scale = 255;
 
-               if ((val = GETEDICTFIELDVALUE(ent, eval_glow_trail)))
-               if (val->_float != 0)
-                       bits |= U_GLOWTRAIL;
-
                if ((val = GETEDICTFIELDVALUE(ent, eval_glow_color)))
                if (val->_float != 0)
                        glowcolor = (int) val->_float;
@@ -585,16 +687,17 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
 
                if (ent != clent)
                {
-                       if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
-                       {
-                               if (ent->v.modelindex && pr_strings[ent->v.model]) // model
-                               {
-                                       if (sv.models[ (int)ent->v.modelindex ]->flags == 0 && (ent->v.effects == EF_NODRAW || scale <= 0 || alpha <= 0))
+//                     if (glowsize == 0 && (bits & U_GLOWTRAIL) == 0) // no effects
+//                     {
+//                             if (ent->v.modelindex && pr_strings[ent->v.model]) // model
+//                             {
+                                       // don't send if flagged for NODRAW and there are no effects
+                                       if (sv.models[(int)ent->v.modelindex]->flags == 0 && ((effects & EF_NODRAW) || scale <= 0 || alpha <= 0))
                                                continue;
-                               }
-                               else // no model and no effects
-                                       continue;
-                       }
+//                             }
+//                             else // no model and no effects
+//                                     continue;
+//                     }
                }
 
                if (msg->maxsize - msg->cursize < 32) // LordHavoc: increased check from 16 to 32
@@ -606,6 +709,9 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
                        return;
                }
 
+               if ((val = GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)) && val->edict == clentnum)
+                       bits = bits | U_EXTERIORMODEL;
+
 // send an update
                baseline = &ent->baseline;
 
@@ -623,7 +729,7 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
                else
                        nextfullupdate = realtime + 0.5f;
 
-               // restore nextfullupdate since this is being sent
+               // restore nextfullupdate since this is being sent for real
                client->nextfullupdate[e] = nextfullupdate;
 
                if (e >= 256)
@@ -632,59 +738,6 @@ void SV_WriteEntitiesToClient (client_t *client, edict_t *clent, sizebuf_t *msg)
                if (ent->v.movetype == MOVETYPE_STEP)
                        bits |= U_STEP;
 
-               if (ent->v.movetype == MOVETYPE_STEP && ((int) ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) // monsters have smoothed walking/flying/swimming movement
-               {
-                       if (!ent->steplerptime || ent->steplerptime > sv.time) // when the level just started...
-                       {
-                               ent->steplerptime = sv.time;
-                               VectorCopy(ent->v.origin, ent->stepoldorigin);
-                               VectorCopy(ent->v.angles, ent->stepoldangles);
-                               VectorCopy(ent->v.origin, ent->steporigin);
-                               VectorCopy(ent->v.angles, ent->stepangles);
-                       }
-                       VectorSubtract(ent->v.origin, ent->steporigin, origin);
-                       VectorSubtract(ent->v.angles, ent->stepangles, angles);
-                       if (DotProduct(origin, origin) >= 0.125 || DotProduct(angles, angles) >= 1.4)
-                       {
-                               // update lerp positions
-                               ent->steplerptime = sv.time;
-                               VectorCopy(ent->steporigin, ent->stepoldorigin);
-                               VectorCopy(ent->stepangles, ent->stepoldangles);
-                               VectorCopy(ent->v.origin, ent->steporigin);
-                               VectorCopy(ent->v.angles, ent->stepangles);
-                       }
-                       movelerp = (sv.time - ent->steplerptime) * 10.0;
-                       if (movelerp > 1) movelerp = 1;
-                       moveilerp = 1 - movelerp;
-                       origin[0] = ent->stepoldorigin[0] * moveilerp + ent->steporigin[0] * movelerp;
-                       origin[1] = ent->stepoldorigin[1] * moveilerp + ent->steporigin[1] * movelerp;
-                       origin[2] = ent->stepoldorigin[2] * moveilerp + ent->steporigin[2] * movelerp;
-                       // choose shortest rotate (to avoid 'spin around' situations)
-                       VectorSubtract(ent->stepangles, ent->stepoldangles, angles);
-                       if (angles[0] < -180) angles[0] += 360;if (angles[0] >= 180) angles[0] -= 360;
-                       if (angles[1] < -180) angles[1] += 360;if (angles[1] >= 180) angles[1] -= 360;
-                       if (angles[2] < -180) angles[2] += 360;if (angles[2] >= 180) angles[2] -= 360;
-                       angles[0] = angles[0] * movelerp + ent->stepoldangles[0];
-                       angles[1] = angles[1] * movelerp + ent->stepoldangles[1];
-                       angles[2] = angles[2] * movelerp + ent->stepoldangles[2];
-                       VectorMA(origin, host_client->latency, ent->v.velocity, origin);
-               }
-               else // copy as they are
-               {
-//                     VectorCopy(ent->v.origin, origin);
-                       VectorCopy(ent->v.angles, angles);
-                       VectorMA(ent->v.origin, host_client->latency, ent->v.velocity, origin);
-                       if (ent->v.movetype == MOVETYPE_STEP) // monster, but airborn, update lerp info
-                       {
-                               // update lerp positions
-                               ent->steplerptime = sv.time;
-                               VectorCopy(ent->v.origin, ent->stepoldorigin);
-                               VectorCopy(ent->v.angles, ent->stepoldangles);
-                               VectorCopy(ent->v.origin, ent->steporigin);
-                               VectorCopy(ent->v.angles, ent->stepangles);
-                       }
-               }
-
                // LordHavoc: old stuff, but rewritten to have more exact tolerances
 //             if ((int)(origin[0]*8.0) != (int)(baseline->origin[0]*8.0))                                             bits |= U_ORIGIN1;
 //             if ((int)(origin[1]*8.0) != (int)(baseline->origin[1]*8.0))                                             bits |= U_ORIGIN2;

diff --git a/world.c b/world.c
index dba8fe9f1cb87376bc713640106dbbbecea458a9..fc2f38a4e6c1429b5d7252f23da2c83b8ac26d0e 100644 (file)
--- a/world.c
+++ b/world.c
@@ -404,55 +404,6 @@ loc0:
 }
 
 
-/*
-===============
-SV_FindTouchedLeafs
-
-===============
-*/
-void SV_FindTouchedLeafs (edict_t *ent, mnode_t *node)
-{
-loc0:
-       if (node->contents == CONTENTS_SOLID)
-               return;
-
-// add an efrag if the node is a leaf
-
-       if ( node->contents < 0)
-       {
-               if (ent->num_leafs == MAX_ENT_LEAFS)
-               {
-                       Con_DPrintf("FindTouchedLeafs overflow\n");
-                       return;
-               }
-
-               ent->leafnums[ent->num_leafs++] = (mleaf_t *)node - sv.worldmodel->leafs - 1;
-               return;
-       }
-
-// recurse down the contacted sides
-
-//     sides = BOX_ON_PLANE_SIDE(ent->v.absmin, ent->v.absmax, node->plane);
-//     if (sides & 1) SV_FindTouchedLeafs (ent, node->children[0]);
-//     if (sides & 2) SV_FindTouchedLeafs (ent, node->children[1]);
-
-       // LordHavoc: optimized recursion
-       switch (BOX_ON_PLANE_SIDE(ent->v.absmin, ent->v.absmax, node->plane))
-       {
-       case 1:
-               node = node->children[0];
-               goto loc0;
-       case 2:
-               node = node->children[1];
-               goto loc0;
-       default: // 3
-               if (node->children[0]->contents != CONTENTS_SOLID)
-                       SV_FindTouchedLeafs (ent, node->children[0]);
-               node = node->children[1];
-               goto loc0;
-       }
-}
-
 /*
 ===============
 SV_LinkEdict
@@ -533,11 +484,6 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
                ent->v.absmax[2] += 1;
        }
 
-// link to PVS leafs
-       ent->num_leafs = 0;
-       if (ent->v.modelindex)
-               SV_FindTouchedLeafs (ent, sv.worldmodel->nodes);
-
        if (ent->v.solid == SOLID_NOT)
                return;
 
@@ -602,7 +548,7 @@ edict_t     *SV_TestEntityPosition (edict_t *ent)
 {
        trace_t trace;
 
-       trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, 0, ent);
+       trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, MOVE_NORMAL, ent);
 
        if (trace.startsolid)
                return sv.edicts;