[Racer-svn] SF.net SVN: racer:[264] trunk/libtrack/Track.cpp

[<jl...@us...>]

Revision: 264
          http://racer.svn.sourceforge.net/racer/?rev=264&view=rev
Author:   jlegg
Date:     2010-03-06 21:32:24 +0000 (Sat, 06 Mar 2010)

Log Message:
-----------
Improve lap position quality (affects car ranking and wrong way warning).

Use shortest distance from end to calculate lap position, instead of shortest distance to start.
Prevent shortest path from going through the source node. Without this, one side of the start line the lap positions could have the wrong gradient, making the wrong way warning appear.
Use correct distances for the triangles in the navigation mesh which touch the end of the lap. This allows proper car ranking when multiple cars are on these triangles.

Modified Paths:
--------------
    trunk/libtrack/Track.cpp

Modified: trunk/libtrack/Track.cpp
===================================================================
--- trunk/libtrack/Track.cpp	2010-03-03 17:15:33 UTC (rev 263)
+++ trunk/libtrack/Track.cpp	2010-03-06 21:32:24 UTC (rev 264)
@@ -290,7 +290,9 @@
          it != start_vertices.end();
          it++)
     {
-        boost::add_edge(source_descriptor, *it, MeshFaces::FaceEdgePointers(0, 0, 0, 0.0), graph);
+        // Use a large length to prevent the shortest path of nearby nodes
+        // going backwards.
+        boost::add_edge(source_descriptor, *it, MeshFaces::FaceEdgePointers(0, 0, 0, 100.0), graph);
     }
     // Link up finish to sink vertex.
     for (std::vector<MeshFaces::VertexGraph::vertex_descriptor>::iterator it = finish_vertices.begin();
@@ -301,14 +303,17 @@
     }
     
     /* Now we have the graph we want. Lets find the minimal distance to each
-     * vertex from the source node.
+     * vertex from the sink node.
      */
     std::vector<MeshFaces::VertexGraph::vertex_descriptor> predecessors(boost::num_vertices(graph));
     std::vector<btScalar> distances(boost::num_vertices(graph));
-    boost::dijkstra_shortest_paths(graph, source_descriptor,
+    boost::dijkstra_shortest_paths(graph, sink_descriptor,
         boost::weight_map(get(&MeshFaces::FaceEdgePointers::length, graph)).
         predecessor_map(&predecessors[0]).distance_map(&distances[0])
         );
+    // The length of the lap is the shortest distance from end to finish,
+    // without the 100m length of the connections to the source node.
+    m_lap_length = distances[source_descriptor] - 100.0;
     /* Now we want to put the distances back into the mesh.
      * We use the u coordinate for face vertices.
      * The same vertex will appear on multiple faces. Normally each vertex has
@@ -318,6 +323,7 @@
     // For each edge, set the right distances on each end.
     std::pair<MeshFaces::VertexGraph::edge_iterator,
               MeshFaces::VertexGraph::edge_iterator> edge_its;
+    btScalar end_cut_off = m_lap_length / 2.0;
     for (edge_its = boost::edges(graph); edge_its.first != edge_its.second; edge_its.first++)
     {
         MeshFaces::VertexGraph::edge_descriptor edge = *(edge_its.first);
@@ -325,34 +331,35 @@
         // Each face vertex is set twice due to the edges both sides of it.
         if (fep.source)
         {
-            if (    boost::source(edge, graph) > sink_descriptor
-                 || boost::target(edge, graph) > sink_descriptor)
+            if ((    boost::source(edge, graph) > sink_descriptor
+                  || boost::target(edge, graph) > sink_descriptor)
+                && distances[fep.source->vertex_index] > end_cut_off)
             {
                 // Must be a copy of a starting vertex placed on the end.
                 // This edge connects to the end of the course.
-                fep.source->texture_coord_u = distances[sink_descriptor];
+                fep.source->texture_coord_u = m_lap_length;
             }
             else
             {
-                fep.source->texture_coord_u = distances[fep.source->vertex_index];
+                fep.source->texture_coord_u = m_lap_length - distances[fep.source->vertex_index];
             }
         }
         if (fep.target)
         {
-            if (   boost::target(edge, graph) > sink_descriptor
-                || boost::source(edge, graph) > sink_descriptor)
+            if ((   boost::target(edge, graph) > sink_descriptor
+                  || boost::source(edge, graph) > sink_descriptor)
+                && distances[fep.target->vertex_index] > end_cut_off)
             {
                 // Must be a copy of a starting vertex placed on the end.
                 // This edge connects to the end of the course.
-                fep.target->texture_coord_u = distances[sink_descriptor];
+                fep.target->texture_coord_u = m_lap_length;
             }
             else
             {
-                fep.target->texture_coord_u = distances[fep.target->vertex_index];
+                fep.target->texture_coord_u = m_lap_length - distances[fep.target->vertex_index];
             }
         }
     }
-    m_lap_length = distances[sink_descriptor];
     DEBUG_MESSAGE("Track is " << m_lap_length << "m long.");
 }
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.