Ticket #169: terrain_triangulation_test2.patch

PatchRData.cpp

@@ -238 +238 @@
                         m_BlendVertexIndices.push_back(((j+1)*vsize)+i);
 
                         // build a splat for this quad
+                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        //!!!!!!!THIS MIGHT NEED TO BE CHANGED AND EVERYTHING ABOVE IT!!!!!!!!!
+                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                         STmpSplat splat;
                         splat.m_Texture=neighbourTextures[k].m_Handle;
                         splat.m_Indices[0]=(u16)(vindex);
@@ -277 +282 @@
             SSplat& splat=m_BlendSplats[splatCount];
             splat.m_IndexStart=m_BlendIndices.size();
             splat.m_Texture=tex;
+            
+            size_t indexBase=m_VBBase->m_Index;
 
             for (size_t k=0;k<splats.size();k++) {
                 if (splats[k].m_Texture==tex) {
+                    /*
                     m_BlendIndices.push_back(splats[k].m_Indices[0]+base);
                     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;
+                    */
+
+                    //save these for convenience
+                    CVector3D v1 = m_BlendVertices[splats[k].m_Indices[0]].m_Position;
+                    CVector3D v2 = m_BlendVertices[splats[k].m_Indices[1]].m_Position;
+                    CVector3D v3 = m_BlendVertices[splats[k].m_Indices[2]].m_Position;
+                    CVector3D v4 = m_BlendVertices[splats[k].m_Indices[3]].m_Position;
+
+                    /*
+                    debug_printf(L"Trying to add vertex1 (%f,%f,%f)\n", v1.X, v1.Y, v1.Z);
+                    debug_printf(L"Trying to add vertex2 (%f,%f,%f)\n", v2.X, v2.Y, v2.Z);
+                    debug_printf(L"Trying to add vertex3 (%f,%f,%f)\n", v3.X, v3.Y, v3.Z);
+                    debug_printf(L"Trying to add vertex4 (%f,%f,%f)\n", v4.X, v4.Y, v4.Z);
+                    */
+
+                    //this is terrible, but: find the set of indices in m_Indices that correspond to the vertices
+                    //being used by the current blend texture so that we can match up the triangulation used
+                    std::list<unsigned short> IndexList;    //store the order indices should be added to m_BlendIndices
+                    for (int p = 0; p < m_Indices.size()-5; p++)
+                    {
+                        if (
+                            m_Vertices[m_Indices[p]-indexBase].m_Position == v1 ||
+                            m_Vertices[m_Indices[p]-indexBase].m_Position == v2 ||
+                            m_Vertices[m_Indices[p]-indexBase].m_Position == v3 ||
+                            m_Vertices[m_Indices[p]-indexBase].m_Position == v4
+                            )
+                        {
+                            //debug_printf(L"Matched\n");
+                            //we've found a match to one of the vertices, but that does not necessarily mean we're at the right set of 
+                            //indices so we check the block of 6 vertices to see if they contain all the vertices we're using
+                            for (int q = p; q < p+6; q++)
+                            {
+                                CVector3D f = m_Vertices[m_Indices[q]-indexBase].m_Position;
+                                //debug_printf(L"Looking at (%f,%f,%f)\n", f.X, f.Y,f.Z);
+                                if (m_Vertices[m_Indices[q]-indexBase].m_Position == v1)
+                                {
+                                    IndexList.push_back(0);
+                                }
+                                else if (m_Vertices[m_Indices[q]-indexBase].m_Position == v2)
+                                {
+                                    IndexList.push_back(1);
+                                }
+                                else if (m_Vertices[m_Indices[q]-indexBase].m_Position == v3)
+                                {
+                                    IndexList.push_back(2);
+                                }
+                                else if (m_Vertices[m_Indices[q]-indexBase].m_Position == v4)
+                                {
+                                    IndexList.push_back(3);
+                                }
+                                else
+                                {
+                                    //this means we've encountered a vertex that's not one of the ones we're looking for so exit out
+                                    CVector3D z = m_Vertices[m_Indices[q]-indexBase].m_Position;
+                                    CVector3D z2 = m_BlendVertices[splats[k].m_Indices[3]].m_Position;
+                                    //debug_printf(L"Failed to match (%f,%f,%f)\n", z.X,z.Y,z.Z);
+                                    IndexList.clear();
+                                    break;
+                                }
+                            }
+                        }
+                        if (IndexList.size() == 6)
+                        {
+                            //found our triangulation so early out for the search
+                            break;
+                        }
+                    }
+                    
+                    if (IndexList.size() != 6)
+                    {
+                        //tried to use debug_assert(IndexList.size() == 6), but that started throwing memory access violations for some reason
+                        debug_printf(L"WARNING: Blend Indices building failed. IndexList does not contain 6 elements.\n");
+                        debug_break();
+                    }
+                    std::list<unsigned short>::iterator it;
+                    //debug_printf(L"About to start adding indices\n");
+                    for (it = IndexList.begin(); it != IndexList.end(); it++)
+                    {
+                        //add the indices in the order we found them in
+                        //debug_printf(L"%i",*it);
+                        //debug_printf(L"\n");
+                        m_BlendIndices.push_back(splats[k].m_Indices[*it]+base);
+                    }
                 }
             }
             splatCount++;
@@ -302 +393 @@
 
     // 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 +422 @@
         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);
+                        
+                        /*
+                        //for triangle strip
+                        m_Indices.push_back(index3);
+                        m_Indices.push_back(index4);
+                        m_Indices.push_back(index2);
+                        m_Indices.push_back(index1);
+                        */
+                    }
+                    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);
+                        
+                        /*
+                        //for triangle strip
+                        m_Indices.push_back(index2);
+                        m_Indices.push_back(index3);
+                        m_Indices.push_back(index1);
+                        m_Indices.push_back(index4);
+                        */
+                    }
+                    
+                    /*
                     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 +674 @@
         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 +707 @@
 
     // 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 +746 @@
         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

@@ -104 +104 @@
     // 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;