Optimize RadarRenderer::renderBoxPyrMesh()

Author: atupone

include/MeshObstacle.h

@@ -24,6 +24,7 @@
 #include <iostream>
 #include <string>
 #include <vector>
+#include <deque>
 
 // Common headers
 #include "vectors.h"
@@ -106,8 +107,18 @@ class MeshObstacle final : public Obstacle
     int getVertexCount() const;
     int getNormalCount() const;
     int getTexcoordCount() const;
-    int getFaceCount() const;
-    MeshFace* getFace(int face) const;
+    int getFaceCount() const
+    {
+        return faces.size();
+    }
+    const MeshFace* getFace(int face) const
+    {
+        return &faces[face];
+    }
+    MeshFace* getFace(int face)
+    {
+        return &faces[face];
+    }
     const float* getPosition() const;
     bool useSmoothBounce() const;
     bool noClusters() const;
@@ -122,13 +133,24 @@ class MeshObstacle final : public Obstacle
     void print(std::ostream& out, const std::string& indent) const override;
     void printOBJ(std::ostream& out, const std::string& indent) const override;
 
+    struct RadarFaceCache
+    {
+        bool  noRadar;
+        float posZ;
+        float sizeZ;
+        int   phydrv;
+        int   vertexCount;
+        float vx[4];
+        float vy[4];
+    };
+    std::vector<RadarFaceCache> radarCache;
+
 private:
     void makeFacePointers(const std::vector<int>& _vertices,
                           const std::vector<int>& _normals,
                           const std::vector<int>& _texcoords,
                           float**& v, float**& n, float**& t);
 
-private:
     static const char* typeName;
 
     std::string name;
@@ -142,8 +164,7 @@ class MeshObstacle final : public Obstacle
     afvec3* normals;
     int texcoordCount;
     afvec2* texcoords;
-    int faceCount, faceSize;
-    MeshFace** faces;
+    std::deque<MeshFace> faces;
     bool smoothBounce;
     bool noclusters;
     bool inverted; // used during building. can be ditched if
@@ -198,16 +219,6 @@ inline int MeshObstacle::getTexcoordCount() const
     return texcoordCount;
 }
 
-inline int MeshObstacle::getFaceCount() const
-{
-    return faceCount;
-}
-
-inline MeshFace* MeshObstacle::getFace(int face) const
-{
-    return faces[face];
-}
-
 inline const float* MeshObstacle::getPosition() const
 {
     return pos;

src/bzflag/RadarRenderer.cxx

@@ -1065,21 +1065,19 @@ void RadarRenderer::renderBoxPyrMesh()
     for (i = 0; i < count; i++)
     {
         const MeshObstacle* mesh = (const MeshObstacle*) meshes[i];
+        const auto* cachePtr = mesh->radarCache.data();
         int faces = mesh->getFaceCount();
 
         for (int f = 0; f < faces; f++)
         {
-            const MeshFace* face = mesh->getFace(f);
+            const auto& cache = cachePtr[f];
             if (enhanced)
             {
-                if (face->getPlane()[2] <= 0.0f)
-                    continue;
-                const BzMaterial* bzmat = face->getMaterial();
-                if ((bzmat != NULL) && bzmat->getNoRadar())
+                if (cache.noRadar)
                     continue;
             }
-            float z = face->getPosition()[2];
-            float bh = face->getSize()[2];
+            float z  = cache.posZ;
+            float bh = cache.sizeZ;
 
             if (BZDBCache::useMeshForRadar)
             {
@@ -1089,18 +1087,24 @@ void RadarRenderer::renderBoxPyrMesh()
 
             const float cs = colorScale(z, bh);
             // draw death faces with a soupcon of red
-            const PhysicsDriver* phydrv = PHYDRVMGR.getDriver(face->getPhysicsDriver());
+            const PhysicsDriver* phydrv = PHYDRVMGR.getDriver(cache.phydrv);
             if ((phydrv != NULL) && phydrv->getIsDeath())
                 glColor4f(0.75f * cs, 0.25f * cs, 0.25f * cs, transScale(z, bh));
             else
                 glColor4f(0.25f * cs, 0.5f * cs, 0.5f * cs, transScale(z, bh));
             // draw the face as a triangle fan
-            int vertexCount = face->getVertexCount();
+            int vertexCount = cache.vertexCount;
             glBegin(GL_TRIANGLE_FAN);
-            for (int v = 0; v < vertexCount; v++)
+            for (int v = 0; v < std::min(vertexCount, 4); v++)
+                glVertex2f(cache.vx[v], cache.vy[v]);
+            if (vertexCount > 4)
             {
-                const float* pos = face->getVertex(v);
-                glVertex2f(pos[0], pos[1]);
+                const MeshFace* face = mesh->getFace(f);
+                for (int v = 4; v < vertexCount; v++)
+                {
+                    const float* pos = face->getVertex(v);
+                    glVertex2f(pos[0], pos[1]);
+                }
             }
             glEnd();
         }