Ticket #887: catch-patch-vertex-height.patch

source/graphics/Patch.h

@@ -61 +61 @@
     // is already in the DrawList
     bool m_bWillBeDrawn;
 
+    bool TileHasVertexBelowHeight(ssize_t x, ssize_t z, float height) const
+    {
+        return m_VertexHeight[x+1][z]   < height
+            || m_VertexHeight[x+1][z+1] < height
+            || m_VertexHeight[x][z+1]   < height
+            || m_VertexHeight[x][z]     < height;
+    }
+
+    void RefreshVertexHeight();
+    void RecalculateMinimumHeight();
+    bool HasAnyVertexBelowHeight(float height) const { return m_MinVertexHeight < height; }
+
+    float GetVertexHeight( ssize_t x, ssize_t z) const { return m_VertexHeight[x][z]; }
+
 public:
     // minipatches (tiles) making up the patch
     CMiniPatch m_MiniPatches[PATCH_SIZE][PATCH_SIZE];
@@ -68 +82 @@
     int m_X,m_Z;
     // parent terrain
     CTerrain* m_Parent;
+    // height of each vertex of the minipatches
+    float m_VertexHeight[PATCH_SIZE+1][PATCH_SIZE+1];
+    // lower vertex height in this patch
+    float m_MinVertexHeight;
 
     // draw state...
     void setDrawState(bool value) { m_bWillBeDrawn = value; };

source/graphics/Patch.cpp

@@ -50 +50 @@
     m_X=x;
     m_Z=z;
 
+    RefreshVertexHeight();
+
     InvalidateBounds();
 }
 
+void CPatch::RefreshVertexHeight()
+{
+    ssize_t init_x = m_X * PATCH_SIZE;
+    ssize_t init_z = m_Z * PATCH_SIZE;
+
+    ssize_t patch_x, patch_z;
+    ssize_t map_x, map_z;
+
+    map_x = init_x;
+    for ( patch_x = 0; patch_x < PATCH_SIZE+1; ++patch_x )
+    {
+        map_z = init_z;
+        for ( patch_z = 0; patch_z < PATCH_SIZE+1; ++patch_z )
+        {
+            m_VertexHeight[patch_x][patch_z] = m_Parent->GetVertexGroundLevel(map_x, map_z);
+            ++map_z;
+        }
+        ++map_x;
+    }
+}
+
+void CPatch::RecalculateMinimumHeight()
+{
+    float min_h = m_VertexHeight[0][0];
+    ssize_t x,z;
+    for ( x=0; x < PATCH_SIZE+1; ++x )
+    {
+        for ( z=0; z < PATCH_SIZE+1; ++z )
+        {
+            min_h = std::min(min_h, m_VertexHeight[x][z]);
+        }
+    }
+    m_MinVertexHeight = min_h;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // CalcBounds: calculating the bounds of this patch
 void CPatch::CalcBounds()

source/renderer/TerrainRenderer.cpp

@@ -528 +528 @@
             m->fancyWaterShader = h;
         }
     }
-    CTerrain* terrain = g_Game->GetWorld()->GetTerrain(); // TODO: stop using g_Game
 
     CLOSTexture& losTexture = g_Renderer.GetScene().GetLOSTexture();
     
@@ -662 +661 @@
     
     float repeatPeriod = (fancy ? WaterMgr->m_RepeatPeriod : 16.0f);
 
+    // Some offsets used to go around counterclockwise while keeping code concise
+    const int DX[] = {1,1,0,0};
+    const int DZ[] = {0,1,1,0};
+
     glBegin(GL_QUADS);
 
     for(size_t i=0; i<m->visiblePatches.size(); i++)
     {
         CPatch* patch = m->visiblePatches[i]->GetPatch();
+        if ( ! patch->HasAnyVertexBelowHeight(WaterMgr->m_WaterHeight) )
+        {
+            continue;
+        }
 
         for(ssize_t dx=0; dx<PATCH_SIZE; dx++)
         {
             for(ssize_t dz=0; dz<PATCH_SIZE; dz++)
             {
-                ssize_t x = (patch->m_X*PATCH_SIZE + dx);
-                ssize_t z = (patch->m_Z*PATCH_SIZE + dz);
-
-                // Some offsets used to go around counterclockwise while keeping code concise
-                const int DX[] = {1,1,0,0};
-                const int DZ[] = {0,1,1,0};
-
-                // is any corner of the tile below the water height? if not, no point rendering it
-                bool shouldRender = false;
-                for (int j = 0; j < 4; j++)
+                if ( ! patch->TileHasVertexBelowHeight(dx, dz, WaterMgr->m_WaterHeight) )
                 {
-                    float terrainHeight = terrain->GetVertexGroundLevel(x + DX[j], z + DZ[j]);
-                    if (terrainHeight < WaterMgr->m_WaterHeight)
-                    {
-                        shouldRender = true;
-                        break;
-                    }
-                }
-                if (!shouldRender)
                     continue;
+                }
 
+                ssize_t x = (patch->m_X*PATCH_SIZE + dx);
+                ssize_t z = (patch->m_Z*PATCH_SIZE + dz);
+
                 for (int j=0; j<4; j++)
                 {
                     ssize_t ix = x + DX[j];
@@ -701 +695 @@
                     float vertX = ix * CELL_SIZE;
                     float vertZ = iz * CELL_SIZE;
 
-                    float terrainHeight = terrain->GetVertexGroundLevel(ix, iz);
+                    float terrainHeight = patch->GetVertexHeight(dx+DX[j], dz+DZ[j]);
 
                     if (fancy)
                     {