implemented PointSuperContents model function as a lower-overhead

alternative to TraceBox, and this also makes profile reports more clear

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

diff --git a/collision.c b/collision.c
index 94c39843f59ae594588836de7ecef3df46829ab1..fbe340f088c5f883dcf7a4cec593fd9490d10ca6 100644 (file)
--- a/collision.c
+++ b/collision.c
@@ -823,14 +823,23 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
        }
 }
 
-void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush)
+qboolean Collision_PointInsideBrushFloat(const vec3_t point, const colbrushf_t *brush)
 {
        int nplane;
        const colplanef_t *plane;
 
-       for (nplane = 0, plane = thatbrush->planes;nplane < thatbrush->numplanes;nplane++, plane++)
+       if (!BoxesOverlap(point, point, brush->mins, brush->maxs))
+               return false;
+       for (nplane = 0, plane = brush->planes;nplane < brush->numplanes;nplane++, plane++)
                if (DotProduct(plane->normal, point) > plane->dist)
-                       return;
+                       return false;
+       return true;
+}
+
+void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush)
+{
+       if (!Collision_PointInsideBrushFloat(point, thatbrush))
+               return;
 
        trace->startsupercontents |= thatbrush->supercontents;
        if (trace->hitsupercontentsmask & thatbrush->supercontents)

diff --git a/collision.h b/collision.h
index 3dd3ba256ad06f5973b75b9672f384a4f138286b..f67c81d1c0dc5a6a809eed676cec6f884e6283da 100644 (file)
--- a/collision.h
+++ b/collision.h
@@ -107,6 +107,7 @@ void Collision_TraceLineBrushFloat(trace_t *trace, const vec3_t linestart, const
 void Collision_TraceLinePolygonFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, int numpoints, const float *points, int supercontents);
 void Collision_TraceLineTriangleMeshFloat(trace_t *trace, const vec3_t linestart, const vec3_t lineend, int numtriangles, const int *element3i, const float *vertex3f, int supercontents, int q3surfaceflags, texture_t *texture, const vec3_t segmentmins, const vec3_t segmentmaxs);
 void Collision_TracePointBrushFloat(trace_t *trace, const vec3_t point, const colbrushf_t *thatbrush);
+qboolean Collision_PointInsideBrushFloat(const vec3_t point, const colbrushf_t *brush);
 
 void Collision_TraceBrushPolygonTransformFloat(trace_t *trace, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int numpoints, const float *points, const matrix4x4_t *polygonmatrixstart, const matrix4x4_t *polygonmatrixend, int supercontents, int q3surfaceflags, texture_t *texture);
 

diff --git a/model_alias.c b/model_alias.c
index ad5b030c30798e7625ded95150e637a13467e3b1..b117fec37fb359ed142addce4c3d8f7931c9a5b2 100644 (file)
--- a/model_alias.c
+++ b/model_alias.c
@@ -846,6 +846,7 @@ void Mod_IDP0_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
 
        loadmodel->num_surfaces = 1;
        loadmodel->nummodelsurfaces = loadmodel->num_surfaces;
@@ -1167,6 +1168,7 @@ void Mod_IDP2_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
 
        if (LittleLong(pinmodel->num_tris) < 1 || LittleLong(pinmodel->num_tris) > 65536)
                Host_Error ("%s has invalid number of triangles: %i", loadmodel->name, LittleLong(pinmodel->num_tris));
@@ -1404,6 +1406,7 @@ void Mod_IDP3_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
        loadmodel->synctype = ST_RAND;
        // convert model flags to EF flags (MF_ROCKET becomes EF_ROCKET, etc)
        i = LittleLong (pinmodel->flags);
@@ -1610,6 +1613,7 @@ void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
 
        loadmodel->numframes = pheader->numscenes;
        loadmodel->num_surfaces = pheader->numshaders;
@@ -1907,6 +1911,7 @@ void Mod_DARKPLACESMODEL_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
 
        // model bbox
        for (i = 0;i < 3;i++)
@@ -2180,6 +2185,7 @@ void Mod_PSKMODEL_Load(model_t *mod, void *buffer, void *bufferend)
        loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
        loadmodel->DrawLight = R_Q1BSP_DrawLight;
        loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+       loadmodel->PointSuperContents = NULL;
        loadmodel->synctype = ST_RAND;
 
        FS_StripExtension(loadmodel->name, animname, sizeof(animname));

diff --git a/model_brush.c b/model_brush.c
index 3baf1aeb5acece5eb5ac001ace48c5a555628a4e..9ddbae8ecbcec4d3ae5b91c4cd03e565fd7d4625 100644 (file)
--- a/model_brush.c
+++ b/model_brush.c
@@ -783,8 +783,16 @@ loc0:
 //#if COLLISIONPARANOID < 2
 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
 {
+       mplane_t *plane;
+       mclipnode_t *nodes = t->hull->clipnodes;
+       mplane_t *planes = t->hull->planes;
+       vec3_t point;
+       VectorCopy(t->start, point);
        while (num >= 0)
-               num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist];
+       {
+               plane = planes + nodes[num].planenum;
+               num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+       }
        num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
        t->trace->startsupercontents |= num;
        if (num & SUPERCONTENTS_LIQUIDSMASK)
@@ -900,6 +908,20 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace,
 #endif
 }
 
+static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+       int num = 0;
+       mplane_t *plane;
+       mclipnode_t *nodes = model->brushq1.hulls[0].clipnodes;
+       mplane_t *planes = model->brushq1.hulls[0].planes;
+       while (num >= 0)
+       {
+               plane = planes + nodes[num].planenum;
+               num = nodes[num].children[(plane->type < 3 ? point[plane->type] : DotProduct(plane->normal, point)) < plane->dist];
+       }
+       return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
+}
+
 void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
 {
 #if 1
@@ -3450,6 +3472,7 @@ void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
        mod->soundfromcenter = true;
        mod->TraceBox = Mod_Q1BSP_TraceBox;
+       mod->PointSuperContents = Mod_Q1BSP_PointSuperContents;
        mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
        mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
        mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
@@ -5277,7 +5300,7 @@ static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model
        colbrushf_t *brush;
        // find which leaf the point is in
        while (node->plane)
-               node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
+               node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
        // point trace the brushes
        leaf = (mleaf_t *)node;
        for (i = 0;i < leaf->numleafbrushes;i++)
@@ -5540,6 +5563,38 @@ static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const
        }
 }
 
+static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point)
+{
+       int i;
+       int supercontents = 0;
+       q3mbrush_t *brush;
+       // test if the point is inside each brush
+       if (model->brush.submodel)
+       {
+               // submodels are effectively one leaf
+               for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+                       if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+                               supercontents |= brush->colbrushf->supercontents;
+       }
+       else
+       {
+               mnode_t *node = model->brush.data_nodes;
+               mleaf_t *leaf;
+               // find which leaf the point is in
+               while (node->plane)
+                       node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist];
+               leaf = (mleaf_t *)node;
+               // now check the brushes in the leaf
+               for (i = 0;i < leaf->numleafbrushes;i++)
+               {
+                       brush = model->brush.data_brushes + leaf->firstleafbrush[i];
+                       if (brush->colbrushf && Collision_PointInsideBrushFloat(point, brush->colbrushf))
+                               supercontents |= brush->colbrushf->supercontents;
+               }
+       }
+       return supercontents;
+}
+
 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
 {
        int supercontents = 0;
@@ -5633,6 +5688,7 @@ void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
 
        mod->soundfromcenter = true;
        mod->TraceBox = Mod_Q3BSP_TraceBox;
+       mod->PointSuperContents = Mod_Q3BSP_PointSuperContents;
        mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
        mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
        mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;

diff --git a/model_shared.h b/model_shared.h
index bc030221b27d37f082a9d0a16a2c12b34022812a..5bea523ecb238e1421146863e94d48c4193cf684 100644 (file)
--- a/model_shared.h
+++ b/model_shared.h
@@ -870,6 +870,8 @@ typedef struct model_s
        void(*DrawLight)(struct entity_render_s *ent, int numsurfaces, const int *surfacelist, const unsigned char *trispvs);
        // trace a box against this model
        void (*TraceBox)(struct model_s *model, int frame, struct trace_s *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask);
+       // find the supercontents value at a point in this model
+       int (*PointSuperContents)(struct model_s *model, int frame, const vec3_t point);
        // fields belonging to some types of model
        model_sprite_t  sprite;
        model_brush_t   brush;

diff --git a/server.h b/server.h
index 6e268803b309b805383d053323740ccaa11920c0..33099d38960828a2ffac821f54a5a75cc3728de5 100644 (file)
--- a/server.h
+++ b/server.h
@@ -469,7 +469,7 @@ int SV_GenericHitSuperContentsMask(const prvm_edict_t *edict);
 // traces a box move against worldmodel and all entities in the specified area
 trace_t SV_Move(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask);
 
-#define SV_PointSuperContents(point) (SV_Move((point), vec3_origin, vec3_origin, (point), sv_gameplayfix_swiminbmodels.integer ? MOVE_NOMONSTERS : MOVE_WORLDONLY, NULL, 0).startsupercontents)
+int SV_PointSuperContents(const vec3_t point);
 
 void SV_FlushBroadcastMessages(void);
 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);

diff --git a/sv_phys.c b/sv_phys.c
index b7adc93ba1c0be1be68fe8d7eb28258f45dfbe91..6c6fd13aa29487a5f9370b481bece079d61b85d0 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -255,6 +255,63 @@ trace_t SV_Move(const vec3_t start, const vec3_t mins, const vec3_t maxs, const
 }
 #endif
 
+int SV_PointSuperContents(const vec3_t point)
+{
+       int supercontents = 0;
+       int i;
+       prvm_edict_t *touch;
+       vec3_t transformed;
+       // matrices to transform into/out of other entity's space
+       matrix4x4_t matrix, imatrix;
+       // model of other entity
+       model_t *model;
+       unsigned int modelindex;
+       int frame;
+       // list of entities to test for collisions
+       int numtouchedicts;
+       prvm_edict_t *touchedicts[MAX_EDICTS];
+
+       // get world supercontents at this point
+       if (sv.worldmodel && sv.worldmodel->PointSuperContents)
+               supercontents = sv.worldmodel->PointSuperContents(sv.worldmodel, 0, point);
+
+       // if sv_gameplayfix_swiminbmodels is off we're done
+       if (!sv_gameplayfix_swiminbmodels.integer)
+               return supercontents;
+
+       // get list of entities at this point
+       numtouchedicts = World_EntitiesInBox(&sv.world, point, point, MAX_EDICTS, touchedicts);
+       if (numtouchedicts > MAX_EDICTS)
+       {
+               // this never happens
+               Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
+               numtouchedicts = MAX_EDICTS;
+       }
+       for (i = 0;i < numtouchedicts;i++)
+       {
+               touch = touchedicts[i];
+
+               // we only care about SOLID_BSP for pointcontents
+               if (touch->fields.server->solid != SOLID_BSP)
+                       continue;
+
+               // might interact, so do an exact clip
+               modelindex = (unsigned int)touch->fields.server->modelindex;
+               if (modelindex >= MAX_MODELS)
+                       continue;
+               model = sv.models[(int)touch->fields.server->modelindex];
+               if (!model || !model->PointSuperContents)
+                       continue;
+               Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+               Matrix4x4_Invert_Simple(&imatrix, &matrix);
+               Matrix4x4_Transform(&imatrix, point, transformed);
+               frame = (int)touch->fields.server->frame;
+               supercontents |= model->PointSuperContents(model, bound(0, frame, (model->numframes - 1)), transformed);
+       }
+
+       return supercontents;
+}
+
 /*
 ===============================================================================