Ticket #169: terrain_triangulation_test4.patch

PatchRData.cpp

@@ -88 +88 @@
 
 struct STmpSplat {
     Handle m_Texture;
-    u16 m_Indices[4];
+    u16 m_Indices[6];   //a splat is now composed of two triangles instead of a single quad
 };
 
+void CPatchRData::GetTriangulation(const CVector3D& v1, const CVector3D& v2, const CVector3D& v3, const CVector3D& v4, std::vector<CVector3D>& out)
+{
+    std::list<unsigned short> triangulation = m_Triangulation[v3];
+    std::list<unsigned short>::iterator it;
+    for (it = triangulation.begin(); it != triangulation.end(); it++)
+    {
+        if (m_Vertices[*it].m_Position == v1)
+            out.push_back(v1);
+        else if (m_Vertices[*it].m_Position == v2)
+            out.push_back(v2);
+        else if (m_Vertices[*it].m_Position == v3)
+            out.push_back(v3);
+        else
+            out.push_back(v4);
+    }
+}
+
 void CPatchRData::BuildBlends()
 {
     m_BlendIndices.clear();
@@ -237 +254 @@
                         m_BlendVertices.push_back(dst);
                         m_BlendVertexIndices.push_back(((j+1)*vsize)+i);
 
-                        // build a splat for this quad
+                        // build a splat for this quad (really two tris)
                         STmpSplat splat;
                         splat.m_Texture=neighbourTextures[k].m_Handle;
-                        splat.m_Indices[0]=(u16)(vindex);
+                        /*splat.m_Indices[0]=(u16)(vindex);
                         splat.m_Indices[1]=(u16)(vindex+1);
                         splat.m_Indices[2]=(u16)(vindex+2);
                         splat.m_Indices[3]=(u16)(vindex+3);
+                        */
+                        
+                        //match up the triangulation calculated by BuildIndices() for this blend tile
+                        std::list<unsigned short> triangulation = m_Triangulation[vtx2.m_Position];
+                        std::list<unsigned short>::iterator it;
+                        int splatIndex = 0;
+                        for (it = triangulation.begin(); it != triangulation.end(); it++)
+                        {
+                            CVector3D pos = m_Vertices[*it].m_Position;
+                            if (m_Vertices[*it].m_Position == vtx0.m_Position)
+                            {
+                                splat.m_Indices[splatIndex++]=((u16)(vindex));
+                            }
+                            else if (m_Vertices[*it].m_Position == vtx1.m_Position)
+                            {
+                                splat.m_Indices[splatIndex++]=((u16)(vindex+1));
+                            }
+                            else if (m_Vertices[*it].m_Position == vtx2.m_Position)
+                            {
+                                splat.m_Indices[splatIndex++]=((u16)(vindex+2));
+                            }
+                            else if (m_Vertices[*it].m_Position == vtx3.m_Position)
+                            {
+                                splat.m_Indices[splatIndex++]=((u16)(vindex+3));
+                            }
+                            else
+                            {
+                                debug_printf(L"WARNING: Triangulation matching failed.");
+                                debug_break();
+                            }
+                        }
                         splats.push_back(splat);
 
                         // add this texture to set of unique splat textures
@@ -284 +332 @@
                     m_BlendIndices.push_back(splats[k].m_Indices[1]+base);
                     m_BlendIndices.push_back(splats[k].m_Indices[2]+base);
                     m_BlendIndices.push_back(splats[k].m_Indices[3]+base);
-                    splat.m_IndexCount+=4;
+                    m_BlendIndices.push_back(splats[k].m_Indices[4]+base);
+                    m_BlendIndices.push_back(splats[k].m_Indices[5]+base);
+                    splat.m_IndexCount+=6;
                 }
             }
             splatCount++;
@@ -302 +352 @@
 
     // release existing indices and bins
     m_Indices.clear();
-    m_ShadowMapIndices.clear();
     m_Splats.clear();
 
     // build grid of textures on this patch and boundaries of adjacent patches
@@ -332 +381 @@
         for (ssize_t j=0;j<PATCH_SIZE;j++) {
             for (ssize_t i=0;i<PATCH_SIZE;i++) {
                 if (texgrid[j][i]==h){
+
+                    //save these values for convenience
+                    u16 index1 = u16(((j+0)*vsize+(i+0))+base);
+                    u16 index2 = u16(((j+0)*vsize+(i+1))+base);
+                    u16 index3 = u16(((j+1)*vsize+(i+1))+base);
+                    u16 index4 = u16(((j+1)*vsize+(i+0))+base);
+
+                    //calculate triangulation
+                    //reminder: incrementing i shifts x coordinates, j shifts z
+                    //first, get all the positions of the vertices in world space
+                    CVector3D v1 = m_Vertices[(j+0)*vsize+(i+0)].m_Position;
+                    CVector3D v2 = m_Vertices[(j+0)*vsize+(i+1)].m_Position;
+                    CVector3D v3 = m_Vertices[(j+1)*vsize+(i+1)].m_Position;
+                    CVector3D v4 = m_Vertices[(j+1)*vsize+(i+0)].m_Position;
+                    
+                    /*
+                    debug_printf(L"Vertex 1 is at position: %f, %f, %f\n", v1.X, v1.Y, v1.Z);
+                    debug_printf(L"Vertex 2 is at position: %f, %f, %f\n", v2.X, v2.Y, v2.Z);
+                    debug_printf(L"Vertex 3 is at position: %f, %f, %f\n", v3.X, v3.Y, v3.Z);
+                    debug_printf(L"Vertex 4 is at position: %f, %f, %f\n", v4.X, v4.Y, v4.Z);
+                    */
+
+                    
+                    //we have two possible triangulations to check: (123, 143) and (234, 214)
+                    //our goal is to pick the one that minimizes the angle between the planes formed by the triangles
+                    //the normals are constructed in such a way as to avoid having to normalize the vectors for the dot product
+                    CVector3D normal1 = (v1-v2).Cross(v3-v2);
+                    CVector3D normal2 = (v1-v4).Cross(v3-v4);
+                    CVector3D normal3 = (v4-v3).Cross(v2-v3);
+                    CVector3D normal4 = (v4-v1).Cross(v2-v1);
+                    float angle1 = normal1.Dot(normal2);    //since we don't need the exact angle, we can just use the value of the dot product
+                    float angle2 = normal3.Dot(normal4);
+
+                    //cos gets smaller as the angle increases so we take the triangulation with the larger value
+                    if (angle1 < angle2)
+                    {
+                        m_Indices.push_back(index3);
+                        m_Indices.push_back(index4);
+                        m_Indices.push_back(index2);
+                        m_Indices.push_back(index2);
+                        m_Indices.push_back(index4);
+                        m_Indices.push_back(index1);
+
+                        //now add to the triangulation map
+                        std::list<unsigned short> triangulation;
+                        triangulation.push_back(index3-base);
+                        triangulation.push_back(index4-base);
+                        triangulation.push_back(index2-base);
+                        triangulation.push_back(index2-base);
+                        triangulation.push_back(index4-base);
+                        triangulation.push_back(index1-base);
+                        m_Triangulation.insert( std::pair<CVector3D,std::list<unsigned short>>(v3,triangulation) );
+                        /* Debug code
+                        std::pair<std::map<CVector3D, std::list<unsigned short>, veccmp>::iterator, bool> ret = m_Triangulation.insert( std::pair<CVector3D,std::list<unsigned short>>(v3,triangulation) );
+                        if(ret.second == false)
+                            debug_break();
+                            */
+                    }
+                    else
+                    {
+                        m_Indices.push_back(index2);
+                        m_Indices.push_back(index3);
+                        m_Indices.push_back(index1);
+                        m_Indices.push_back(index1);
+                        m_Indices.push_back(index3);
+                        m_Indices.push_back(index4);
+                        
+                        //now add to the triangulation map
+                        std::list<unsigned short> triangulation;
+                        triangulation.push_back(index2-base);
+                        triangulation.push_back(index3-base);
+                        triangulation.push_back(index1-base);
+                        triangulation.push_back(index1-base);
+                        triangulation.push_back(index3-base);
+                        triangulation.push_back(index4-base);
+                        m_Triangulation.insert( std::pair<CVector3D,std::list<unsigned short>>(v3,triangulation) );
+                        /* Debug code
+                        std::pair<std::map<CVector3D, std::list<unsigned short>, veccmp>::iterator, bool> ret = m_Triangulation.insert( std::pair<CVector3D,std::list<unsigned short>>(v3,triangulation) );
+                        if(ret.second == false)
+                            debug_break();
+                            */
+                    }
+                    
+                    /*
                     m_Indices.push_back(u16(((j+0)*vsize+(i+0))+base));
                     m_Indices.push_back(u16(((j+0)*vsize+(i+1))+base));
                     m_Indices.push_back(u16(((j+1)*vsize+(i+1))+base));
                     m_Indices.push_back(u16(((j+1)*vsize+(i+0))+base));
+                    */
+
                 }
             }
         }
         splat.m_IndexCount=m_Indices.size()-splat.m_IndexStart;
     }
-
-    // build indices for the shadow map pass
-    for (ssize_t j=0;j<PATCH_SIZE;j++) {
-        for (ssize_t i=0;i<PATCH_SIZE;i++) {
-            m_ShadowMapIndices.push_back(u16(((j+0)*vsize+(i+0))+base));
-            m_ShadowMapIndices.push_back(u16(((j+0)*vsize+(i+1))+base));
-            m_ShadowMapIndices.push_back(u16(((j+1)*vsize+(i+1))+base));
-            m_ShadowMapIndices.push_back(u16(((j+1)*vsize+(i+0))+base));
-        }
-    }
 }
 
 
@@ -519 +644 @@
         ogl_tex_bind(splat.m_Texture);
 
         if (!g_Renderer.m_SkipSubmit) {
-            glDrawElements(GL_QUADS, (GLsizei)splat.m_IndexCount,
+            glDrawElements(GL_TRIANGLES, (GLsizei)splat.m_IndexCount,
                 GL_UNSIGNED_SHORT, &m_Indices[splat.m_IndexStart]);
         }
-
+        
         // bump stats
         g_Renderer.m_Stats.m_DrawCalls++;
         g_Renderer.m_Stats.m_TerrainTris+=splat.m_IndexCount/2;
@@ -552 +677 @@
 
     // render all base splats at once
     if (!g_Renderer.m_SkipSubmit) {
-        glDrawElements(GL_QUADS,(GLsizei)m_Indices.size(),GL_UNSIGNED_SHORT,&m_Indices[0]);
+        glDrawElements(GL_TRIANGLES,(GLsizei)m_Indices.size(),GL_UNSIGNED_SHORT,&m_Indices[0]);
     }
 
     // bump stats
@@ -591 +716 @@
         ogl_tex_bind(splat.m_Texture);
 
         if (!g_Renderer.m_SkipSubmit) {
-            glDrawElements(GL_QUADS, (GLsizei)splat.m_IndexCount,
+            glDrawElements(GL_TRIANGLES, (GLsizei)splat.m_IndexCount,
                 GL_UNSIGNED_SHORT, &m_BlendIndices[splat.m_IndexStart]);
         }
 

PatchRData.h

@@ -40 +40 @@
     void RenderBlends();
     void RenderOutline();
     void RenderStreams(int streamflags, bool losColor);
+    void GetTriangulation(const CVector3D& v1, const CVector3D& v2, const CVector3D& v3, const CVector3D& v4, std::vector<CVector3D>& out);
 
 private:
     struct SSplat {
@@ -82 +83 @@
         int m_Priority;
     };
 
+    struct veccmp
+    {
+        //comparison function for use by the triangulation map
+        bool operator() (const CVector3D& lhs, const CVector3D& rhs) const 
+        {
+            if (lhs.Y < rhs.Y)
+                return true;
+            else if (lhs.Y == rhs.Y)
+            {
+                if (lhs.Z < rhs.Z)
+                    return true;
+                else if (lhs.Z == rhs.Z)
+                {
+                    if (lhs.X < rhs.X)
+                        return true;
+                    else
+                        return false;
+                }
+                else
+                    return false;
+            }
+            else 
+                return false; 
+        }
+    };
+
     // build this renderdata object
     void Build();
 
@@ -104 +131 @@
     // indices into base vertices for the base splats
     std::vector<unsigned short> m_Indices;
 
-    // indices into base vertices for the shadow map pass
-    std::vector<unsigned short> m_ShadowMapIndices;
-
     // list of base splats to apply to this patch
     std::vector<SSplat> m_Splats;
 
@@ -122 +146 @@
 
     // splats used in blend pass
     std::vector<SSplat> m_BlendSplats;
+
+    // stores the triangulation used for individual tiles to improve triangulation matching performance
+    // it is keyed on the third vertex of a tile (the i+1, j+1 one)
+    std::map<CVector3D, std::list<unsigned short>, veccmp> m_Triangulation;
 };
 
 

TerrainOverlay.cpp

@@ -23 +23 @@
 #include "ps/Game.h"
 #include "ps/World.h"
 #include "graphics/Terrain.h"
+#include "graphics/Patch.h"
+#include "renderer/PatchRData.h"
 #include "maths/MathUtil.h"
 #include "lib/ogl.h"
 
@@ -182 +184 @@
     
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
+    /*
     CVector3D pos;
     glBegin(GL_QUADS);
         glColor4fv(colour.FloatArray());
@@ -190 +193 @@
         m_Terrain->CalcPosition(i+1, j+1, pos); glVertex3fv(pos.GetFloatArray());
         m_Terrain->CalcPosition(i,   j+1, pos); glVertex3fv(pos.GetFloatArray());
     glEnd();
+    */
+
+    //because the terrain now renders as triangles instead of quads, trying to draw a quad on top of the terrain results in nasty z-fighting so 
+    //we draw triangles and match it up to the triangulation of the underlying patch
+    CPatch* patch = m_Terrain->GetPatch(i/PATCH_SIZE,j/PATCH_SIZE);
+    if (patch != NULL)
+    {
+        if (patch->GetRenderData() != NULL)
+        {
+            CPatchRData* renderPatch = (CPatchRData*)patch->GetRenderData();
+            CVector3D v1; m_Terrain->CalcPosition(i,   j,   v1);
+            CVector3D v2; m_Terrain->CalcPosition(i+1, j,   v2);
+            CVector3D v3; m_Terrain->CalcPosition(i+1, j+1, v3);
+            CVector3D v4; m_Terrain->CalcPosition(i,   j+1, v4);
+
+            std::vector<CVector3D> vertices(6);
+            renderPatch->GetTriangulation(v1,v2,v3,v4, vertices);
+
+            /* I clearly have no idea what I'm doing here...
+            unsigned short indices[] = {0,1,2,3,4,5,6};
+            glVertexPointer (3, GL_FLOAT, (GLsizei)sizeof(CVector3D), &vertices);
+            glColorPointer(4,GL_FLOAT,(GLsizei)sizeof(colour.FloatArray()),colour.FloatArray());
+            glDrawElements(GL_TRIANGLES, (GLsizei)vertices.size(),GL_UNSIGNED_SHORT, indices);
+            */
+
+            glBegin(GL_TRIANGLES);
+                glColor4fv(colour.FloatArray());
+                for (size_t k = 0; k < vertices.size(); k++)
+                    glVertex3fv(vertices[k].GetFloatArray());
+            glEnd();
+        }
+    }
 }
 
 void TerrainOverlay::RenderTileOutline(const CColor& colour, int line_width, bool draw_hidden)