BoxOnPlaneSideFunc code - gone, replaced by BoxOnPlaneSide

BOX_ON_PLANE_SIDE macro - gone, no replacement necessary (use BoxOnPlaneSide)
R_CullBox and R_CulledBox macros have been replaced by optimized functions
this gets a minor speed gain overall

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

diff --git a/gl_rmain.c b/gl_rmain.c
index 6a177423ad3b9a288deaf23069a50f4291096c5e..8948594a0727d8ebb8b888183ba3cb448b57c73b 100644 (file)
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -327,6 +327,100 @@ void GL_Init (void)
        qglEnable(GL_TEXTURE_2D);
 }
 
+int R_CullBox(const vec3_t emins, const vec3_t emaxs)
+{
+       int i;
+       mplane_t *p;
+       for (i = 0;i < 4;i++)
+       {
+               p = frustum + i;
+               switch(p->signbits)
+               {
+               default:
+               case 0:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return true;
+                       break;
+               case 1:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return true;
+                       break;
+               case 2:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return true;
+                       break;
+               case 3:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return true;
+                       break;
+               case 4:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2] < p->dist)
+                               return true;
+                       break;
+               case 5:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2] < p->dist)
+                               return true;
+                       break;
+               case 6:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2] < p->dist)
+                               return true;
+                       break;
+               case 7:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2] < p->dist)
+                               return true;
+                       break;
+               }
+       }
+       return false;
+}
+
+int R_NotCulledBox(const vec3_t emins, const vec3_t emaxs)
+{
+       int i;
+       mplane_t *p;
+       for (i = 0;i < 4;i++)
+       {
+               p = frustum + i;
+               switch(p->signbits)
+               {
+               default:
+               case 0:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return false;
+                       break;
+               case 1:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return false;
+                       break;
+               case 2:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return false;
+                       break;
+               case 3:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2] < p->dist)
+                               return false;
+                       break;
+               case 4:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2] < p->dist)
+                               return false;
+                       break;
+               case 5:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2] < p->dist)
+                               return false;
+                       break;
+               case 6:
+                       if (p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2] < p->dist)
+                               return false;
+                       break;
+               case 7:
+                       if (p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2] < p->dist)
+                               return false;
+                       break;
+               }
+       }
+       return true;
+}
+
 
 //==================================================================================
 

diff --git a/mathlib.c b/mathlib.c
index 7846af91a6a90019e80c7791acd40fc1adbae6e3..96090b50b49ff49fc2a49481862fb26d3c157c46 100644 (file)
--- a/mathlib.c
+++ b/mathlib.c
@@ -276,79 +276,15 @@ void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,
 /*-----------------------------------------------------------------*/
 
 
-// LordHavoc note 1:
-// BoxOnPlaneSide did a switch on a 'signbits' value and had optimized
-// assembly in an attempt to accelerate it further, very inefficient
-// considering that signbits of the frustum planes only changed each
-// frame, and the world planes changed only at load time.
-// So, to optimize it further I took the obvious route of storing a function
-// pointer in the plane struct itself, and shrunk each of the individual
-// cases to a single return statement.
-// LordHavoc note 2:
-// realized axial cases would be a nice speedup for world geometry, although
-// never useful for the frustum planes.
-int BoxOnPlaneSideX (vec3_t emins, vec3_t emaxs, mplane_t *p) {return p->dist <= emins[0] ? 1 : (p->dist >= emaxs[0] ? 2 : 3);}
-int BoxOnPlaneSideY (vec3_t emins, vec3_t emaxs, mplane_t *p) {return p->dist <= emins[1] ? 1 : (p->dist >= emaxs[1] ? 2 : 3);}
-int BoxOnPlaneSideZ (vec3_t emins, vec3_t emaxs, mplane_t *p) {return p->dist <= emins[2] ? 1 : (p->dist >= emaxs[2] ? 2 : 3);}
-int BoxOnPlaneSide0 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) < p->dist) << 1));}
-int BoxOnPlaneSide1 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) < p->dist) << 1));}
-int BoxOnPlaneSide2 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) < p->dist) << 1));}
-int BoxOnPlaneSide3 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) < p->dist) << 1));}
-int BoxOnPlaneSide4 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));}
-int BoxOnPlaneSide5 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));}
-int BoxOnPlaneSide6 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));}
-int BoxOnPlaneSide7 (vec3_t emins, vec3_t emaxs, mplane_t *p) {return (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));}
-
 void BoxOnPlaneSideClassify(mplane_t *p)
 {
-       switch(p->type)
-       {
-       case 0: // x axis
-               p->BoxOnPlaneSideFunc = BoxOnPlaneSideX;
-               break;
-       case 1: // y axis
-               p->BoxOnPlaneSideFunc = BoxOnPlaneSideY;
-               break;
-       case 2: // z axis
-               p->BoxOnPlaneSideFunc = BoxOnPlaneSideZ;
-               break;
-       default:
-               if (p->normal[2] < 0) // 4
-               {
-                       if (p->normal[1] < 0) // 2
-                       {
-                               if (p->normal[0] < 0) // 1
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide7;
-                               else
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide6;
-                       }
-                       else
-                       {
-                               if (p->normal[0] < 0) // 1
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide5;
-                               else
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide4;
-                       }
-               }
-               else
-               {
-                       if (p->normal[1] < 0) // 2
-                       {
-                               if (p->normal[0] < 0) // 1
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide3;
-                               else
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide2;
-                       }
-                       else
-                       {
-                               if (p->normal[0] < 0) // 1
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide1;
-                               else
-                                       p->BoxOnPlaneSideFunc = BoxOnPlaneSide0;
-                       }
-               }
-               break;
-       }
+       p->signbits = 0;
+       if (p->normal[0] < 0) // 1
+               p->signbits |= 1;
+       if (p->normal[1] < 0) // 2
+               p->signbits |= 2;
+       if (p->normal[2] < 0) // 4
+               p->signbits |= 4;
 }
 
 void PlaneClassify(mplane_t *p)
@@ -364,6 +300,32 @@ void PlaneClassify(mplane_t *p)
        BoxOnPlaneSideClassify(p);
 }
 
+int BoxOnPlaneSide (const vec3_t emins, const vec3_t emaxs, const mplane_t *p)
+{
+       if (p->type < 3)
+               return ((emaxs[p->type] >= p->dist) | ((emins[p->type] < p->dist) << 1));
+       switch(p->signbits)
+       {
+       default:
+       case 0:
+               return (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) < p->dist) << 1));
+       case 1:
+               return (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) < p->dist) << 1));
+       case 2:
+               return (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) < p->dist) << 1));
+       case 3:
+               return (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) < p->dist) << 1));
+       case 4:
+               return (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));
+       case 5:
+               return (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));
+       case 6:
+               return (((p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));
+       case 7:
+               return (((p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2]) >= p->dist) | (((p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2]) < p->dist) << 1));
+       }
+}
+
 void AngleVectors (const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
 {
        double angle, sr, sp, sy, cr, cp, cy;

diff --git a/mathlib.h b/mathlib.h
index afb24dded28878abcec45a9879aa7b79bcff10a0..cffbbbc88b8f9f3c3a511dd5664f8b95a54c6b6d 100644 (file)
--- a/mathlib.h
+++ b/mathlib.h
@@ -156,22 +156,7 @@ void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up);
 void VectorVectorsDouble(const double *forward, double *right, double *up);
 
 void PlaneClassify(struct mplane_s *p);
-
-#define BOX_ON_PLANE_SIDE(emins, emaxs, p)     \
-       (((p)->type < 3)?                                               \
-       (                                                                               \
-               ((p)->dist <= (emins)[(p)->type])?      \
-                       1                                                               \
-               :                                                                       \
-               (                                                                       \
-                       ((p)->dist >= (emaxs)[(p)->type])?\
-                               2                                                       \
-                       :                                                               \
-                               3                                                       \
-               )                                                                       \
-       )                                                                               \
-       :                                                                               \
-               (p)->BoxOnPlaneSideFunc( (emins), (emaxs), (p)))
+int BoxOnPlaneSide (const vec3_t emins, const vec3_t emaxs, const struct mplane_s *p);
 
 #define PlaneDist(point,plane)  ((plane)->type < 3 ? (point)[(plane)->type] : DotProduct((point), (plane)->normal))
 #define PlaneDiff(point,plane) (((plane)->type < 3 ? (point)[(plane)->type] : DotProduct((point), (plane)->normal)) - (plane)->dist)

diff --git a/model_brush.h b/model_brush.h
index 26c1c15f08c22f1338a1716976b0bb678b0145c4..ede0144e0732068f417befe78fb9f9654a589112 100644 (file)
--- a/model_brush.h
+++ b/model_brush.h
@@ -51,8 +51,7 @@ typedef struct mplane_s
        float dist;
        // for texture axis selection and fast side tests
        int type;
-       // LordHavoc: faster than id's signbits system
-       int (*BoxOnPlaneSideFunc) (vec3_t emins, vec3_t emaxs, struct mplane_s *p);
+       int signbits;
 }
 mplane_t;
 

diff --git a/render.h b/render.h
index b4e7c3a32a5ac5dba0d742420fa73527a4ce7daf..ab437b952a968b8558ecea4ab8df845d32af5ed4 100644 (file)
--- a/render.h
+++ b/render.h
@@ -128,9 +128,8 @@ void R_DrawSpriteModel (entity_render_t *ent);
 
 //#define PARANOID 1
 
-// LordHavoc: was a major time waster
-#define R_CullBox(mins,maxs) (frustum[0].BoxOnPlaneSideFunc(mins, maxs, &frustum[0]) == 2 || frustum[1].BoxOnPlaneSideFunc(mins, maxs, &frustum[1]) == 2 || frustum[2].BoxOnPlaneSideFunc(mins, maxs, &frustum[2]) == 2 || frustum[3].BoxOnPlaneSideFunc(mins, maxs, &frustum[3]) == 2)
-#define R_NotCulledBox(mins,maxs) (frustum[0].BoxOnPlaneSideFunc(mins, maxs, &frustum[0]) != 2 && frustum[1].BoxOnPlaneSideFunc(mins, maxs, &frustum[1]) != 2 && frustum[2].BoxOnPlaneSideFunc(mins, maxs, &frustum[2]) != 2 && frustum[3].BoxOnPlaneSideFunc(mins, maxs, &frustum[3]) != 2)
+int R_CullBox(const vec3_t emins, const vec3_t emaxs);
+int R_NotCulledBox(const vec3_t emins, const vec3_t emaxs);
 
 extern qboolean fogenabled;
 extern vec3_t fogcolor;

diff --git a/sv_main.c b/sv_main.c
index 0a5b5bdf8c500f8de57c1d204f52d538106b5d40..a65938f1828fbd3febd0135448c1bb089a0b0141 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -489,7 +489,7 @@ loc0:
        }
 
        // node - recurse down the BSP tree
-       switch (BOX_ON_PLANE_SIDE(mins, maxs, node->plane))
+       switch (BoxOnPlaneSide(mins, maxs, node->plane))
        {
        case 1: // front
                node = node->children[0];