[Racer-svn] SF.net SVN: racer:[252] trunk
Status: Alpha
Brought to you by:
jlegg
Menu
▾
▴
[Racer-svn] SF.net SVN: racer:[252] trunk
|
From: <jl...@us...> - 2010-02-17 03:49:36
|
Revision: 252
http://racer.svn.sourceforge.net/racer/?rev=252&view=rev
Author: jlegg
Date: 2010-02-17 03:49:29 +0000 (Wed, 17 Feb 2010)
Log Message:
-----------
Find the cars' positions on the AI mesh as they move.
Modified Paths:
--------------
trunk/libtrack/Makefile.am
trunk/libtrack/Mesh/MeshFaces.cpp
trunk/libtrack/Mesh/MeshFaces.h
trunk/libtrack/path/PathEdge.cpp
trunk/libtrack/path/PathVertex.cpp
trunk/racer/Engine/GameObjects/Car.cpp
trunk/racer/Engine/GameObjects/Car.h
trunk/racer/Engine/GameScene.cpp
Added Paths:
-----------
trunk/libtrack/Geometry.h
trunk/libtrack/NearTrack.cpp
trunk/libtrack/NearTrack.h
Added: trunk/libtrack/Geometry.h
===================================================================
--- trunk/libtrack/Geometry.h (rev 0)
+++ trunk/libtrack/Geometry.h 2010-02-17 03:49:29 UTC (rev 252)
@@ -0,0 +1,135 @@
+/** @file Libtrack/Geometry.h
+ * @brief Declare the Track::Plane, and Track::Line classes.
+ * @author James Legg
+ */
+/* Copyright © 2010 James Legg.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+*/
+
+#ifndef LIBTRACK_GEOMETRY_H
+#define LIBTRACK_GEOMETRY_H
+
+#include <LinearMath/btVector3.h>
+#include <cmath>
+
+namespace Track
+{
+
+/// A three dimensional plane.
+class Plane
+{
+ public:
+ /** Make a plane containg points p such that vector * p = distance.
+ *
+ * If used as a half space, find_side will return true if the point
+ * lies further in the direction of vector. Negate distance and vector
+ * to define the same plane but the opposite half space.
+ */
+ Plane(btVector3 vector, btScalar distance)
+ : m_vector(vector)
+ , m_distance(distance)
+ {
+ normalise();
+ }
+ /// Construct without initalising plane.
+ Plane()
+ {
+ };
+ /// Determine which side of the plane a point is on
+ inline bool find_side(btVector3 point) const
+ {
+ return find_signed_distance(point) < 0.0;
+ }
+ /// Find minimum distance to the plane.
+ inline btScalar find_distance(btVector3 point) const
+ {
+ return std::abs(find_signed_distance(point));
+ }
+ /// Find signed minimum distance to the plane.
+ inline btScalar find_signed_distance(btVector3 point) const
+ {
+ return point.dot(m_vector) + m_distance;
+ }
+ /// Find the nearest point to the plane.
+ inline btVector3 find_nearest_point(btVector3 point) const
+ {
+ return point - m_vector * find_signed_distance(point);
+
+ }
+ protected:
+ btVector3 m_vector;
+ btScalar m_distance;
+ /** Put plane in Hessian normal form.
+ * This makes m_vector unit length, but keeps the object describing
+ * the same plane. It means that some functions are simpler as they
+ * do not need to consider the length of m_vector.
+ */
+ inline void normalise()
+ {
+ btScalar length = m_vector.length();
+ m_vector = m_vector / length;
+ m_distance /= length;
+ }
+};
+
+/// A three dimensional line, half line, or line segment.
+class Line
+{
+ public:
+ Line(btVector3 begin, btVector3 end)
+ : m_begin(begin)
+ , m_end(end)
+ , m_vector(end - begin)
+ , m_length2(m_vector.length2())
+ {
+ }
+ Line()
+ {}
+ /** Find the closest point on the line segment to the given point.
+ * @param point The point to check.
+ * @return value indicating distance along line. 0 is the beginning,
+ * and 1 is the end of the line segment.
+ */
+ inline btScalar closest_parametric(btVector3 point) const
+ {
+ return (point - m_begin).dot(m_vector) / m_length2;
+ }
+ /** Like closest_parametric but clamped to fit between the begining
+ * and the end point.
+ */
+ inline btScalar closest_parametric_segment(btVector3 point) const
+ {
+ btScalar d = closest_parametric(point);
+ if (d < 0.0) return 0.0;
+ if (d > 1.0) return 1.0;
+ return d;
+ }
+
+ inline btVector3 closest_point_segment(btVector3 point) const
+ {
+ return m_begin + m_vector * closest_parametric_segment(point);
+ }
+ /** Return a plane that contains the line and the direction of vector.
+ */
+ inline Plane get_plane_including(btVector3 vector) const
+ {
+ // Find vector for plane normal.
+ btVector3 plane_normal = m_vector.cross(vector);
+ plane_normal = plane_normal.normalized();
+ return Plane(plane_normal, -(plane_normal.dot(m_begin)));
+ }
+ protected:
+ btVector3 m_begin;
+ btVector3 m_end;
+ /// m_end - m_begin.
+ btVector3 m_vector;
+ /// square of the length of m_vector.
+ btScalar m_length2;
+};
+
+} // namespace Track
+
+#endif // LIBTRACK_GEOMETRY_H
Modified: trunk/libtrack/Makefile.am
===================================================================
--- trunk/libtrack/Makefile.am 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/libtrack/Makefile.am 2010-02-17 03:49:29 UTC (rev 252)
@@ -7,6 +7,8 @@
Debug.h\
Drawable.cpp Drawable.h\
FormErrors.h\
+ Geometry.h\
+ NearTrack.cpp NearTrack.h\
OcclusionTester.cpp OcclusionTester.h\
PieceDistortion.cpp PieceDistortion.h\
SegmentConnection.cpp SegmentConnection.h\
Modified: trunk/libtrack/Mesh/MeshFaces.cpp
===================================================================
--- trunk/libtrack/Mesh/MeshFaces.cpp 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/libtrack/Mesh/MeshFaces.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -8,14 +8,15 @@
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
*/
-#include <fstream>
#include "MeshFaces.h"
#include "../stream_loader.h"
-
#include <Debug.h>
+#include <fstream>
+#include <LinearMath/btMatrix3x3.h>
+
namespace Track
{
@@ -87,6 +88,54 @@
{
}
+btVector3 MeshFaces::FaceGraph::to_face_coords(btVector3 world_coords) const
+{
+ btVector3 local = world_coords - vertex_positions[0];
+ return btVector3(world_to_face.tdotx(local),
+ world_to_face.tdoty(local),
+ world_to_face.tdotz(local));
+}
+
+btVector3 MeshFaces::FaceGraph::to_world_coords(btVector3 face_coords) const
+{
+ btVector3 local = btVector3(face_to_world.tdotx(face_coords),
+ face_to_world.tdoty(face_coords),
+ face_to_world.tdotz(face_coords));
+ return local + vertex_positions[0];
+}
+
+void MeshFaces::FaceGraph::set_conversions()
+{
+ face_to_world = btMatrix3x3(edges[0].x(), edges[0].y(), edges[0].z(),
+ edges[1].x(), edges[1].y(), edges[1].z(),
+ face_normal.x(), face_normal.y(), face_normal.z());
+ world_to_face = face_to_world.inverse();
+ edge_line_segments[0] = Line(vertex_positions[0], vertex_positions[1]);
+ edge_line_segments[1] = Line(vertex_positions[1], vertex_positions[2]);
+ edge_line_segments[2] = Line(vertex_positions[2], vertex_positions[0]);
+ for (int i = 0; i < 3; i++)
+ {
+ edge_planes[i] = edge_line_segments[i].get_plane_including(face_normal);
+ }
+
+ face_plane = Plane(face_normal, -face_normal.dot(vertex_positions[0]));
+}
+
+btVector3 MeshFaces::FaceGraph::find_nearest_point(btVector3 position) const
+{
+ for (int i = 0; i < 3; i++)
+ {
+ if (!edge_planes[i].find_side(position))
+ {
+ // outside, find nearest point on the line segment.
+ return edge_line_segments[i].closest_point_segment(position);
+ }
+ }
+ // On the inside of the triangle.
+ // Find the nearest point to the plane, because that is the nearest point.
+ return face_plane.find_nearest_point(position);
+}
+
MeshFaces::MeshFaces()
{
}
@@ -267,9 +316,16 @@
// copy information about the face to the graph.
face_graph = FaceGraph(*face_it);
// add additional data about the face.
- face_graph.face_centre = (vertices_position[face_it->fv1.vertex_index] +
- vertices_position[face_it->fv2.vertex_index] +
- vertices_position[face_it->fv3.vertex_index]) / 3.0;
+ face_graph.vertex_positions[0] = vertices_position[face_it->fv1.vertex_index];
+ face_graph.vertex_positions[1] = vertices_position[face_it->fv2.vertex_index];
+ face_graph.vertex_positions[2] = vertices_position[face_it->fv3.vertex_index];
+ face_graph.face_centre = (face_graph.vertex_positions[0] +
+ face_graph.vertex_positions[1] +
+ face_graph.vertex_positions[2]) / 3.0;
+ face_graph.edges[0] = face_graph.vertex_positions[1] - face_graph.vertex_positions[0];
+ face_graph.edges[1] = face_graph.vertex_positions[2] - face_graph.vertex_positions[0];
+ face_graph.face_normal = face_graph.edges[0].cross(face_graph.edges[1]).normalized();
+ face_graph.set_conversions();
}
return result;
}
@@ -425,4 +481,15 @@
}
}
+void MeshFaces::set_source(bool is_edge, unsigned long int object_name)
+{
+ for (std::vector<Face>::iterator it = faces.begin();
+ it != faces.end();
+ it++)
+ {
+ it->is_edge = is_edge;
+ it->object_name = object_name;
+ }
}
+
+}
Modified: trunk/libtrack/Mesh/MeshFaces.h
===================================================================
--- trunk/libtrack/Mesh/MeshFaces.h 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/libtrack/Mesh/MeshFaces.h 2010-02-17 03:49:29 UTC (rev 252)
@@ -16,6 +16,7 @@
#include <iostream>
#include <LinearMath/btVector3.h>
+#include <LinearMath/btMatrix3x3.h>
#include <BulletCollision/CollisionShapes/btTriangleMesh.h>
/* gcc >= 4.3 Depreciates hash_set & hash_map, causing warnings to be emited when
@@ -27,6 +28,7 @@
#undef BOOST_NO_HASH
#include "../AxisAlignedBoundingBox.h"
+#include "../Geometry.h"
namespace Track
{
@@ -92,6 +94,11 @@
FaceVertex fv2;
/// Information about the third vertex of the triangle.
FaceVertex fv3;
+
+ /// True if the face comes from an edge, false if from a vertex.
+ bool is_edge;
+ /// The name of the PathEdge or PathVertex the face originated from.
+ unsigned long int object_name;
};
// extra information about a face useful in the graph
@@ -99,7 +106,35 @@
{
FaceGraph() {};
FaceGraph(const Face & face);
+ /// World coordinates of the average position of the vertices.
btVector3 face_centre;
+ /// World space normal of the face.
+ btVector3 face_normal;
+ btVector3 vertex_positions[3];
+ /// World space vector from fv1 to fv2 and from fv1 to fv3
+ btVector3 edges[2];
+
+ /// Matrix to convert world coordinates into face coordinates
+ btMatrix3x3 world_to_face;
+ /// Matrix to convert face coordinates into world coordinates.
+ btMatrix3x3 face_to_world;
+
+ /// Plane including one of the edges, and the normal.
+ Plane edge_planes[3];
+ /// Edge segment for each edge.
+ Line edge_line_segments[3];
+ /// Plane containing the entire triangle.
+ Plane face_plane;
+
+ /// Set conversion matrixes, Lines and Planes from face_normal, edges, and vertex_positions.
+ void set_conversions();
+
+ /// convert a world space vector to face coordinates.
+ btVector3 to_face_coords(btVector3 world_coords) const;
+ /// convert a face coordinate vector to world space.
+ btVector3 to_world_coords(btVector3 face_coords) const;
+ /// Find the nearest point on the face to a world space vector in world space.
+ btVector3 find_nearest_point(btVector3 position) const;
};
/// An edge between two vertices in the same face.
@@ -249,6 +284,13 @@
* @param source The MeshFaces to copy data from.
*/
void operator|=(const MeshFaces & source);
+
+ /** Set the source data in all faces of the mesh.
+ * Sets is_face and object_name to the same values for all faces.
+ * @param is_edge true if an edge, false if a vertex.
+ * @param object_name the unique object identifier of the source.
+ */
+ void set_source(bool is_edge, unsigned long int object_name);
protected:
void load_from_stream(std::istream & source);
Added: trunk/libtrack/NearTrack.cpp
===================================================================
--- trunk/libtrack/NearTrack.cpp (rev 0)
+++ trunk/libtrack/NearTrack.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -0,0 +1,180 @@
+/** @file libtrack/NearTrack.cpp
+ * @brief Implement the Track::NearTrack class.
+ * @author James Legg
+ */
+/* Copyright © 2010 James Legg.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+*/
+
+#include "NearTrack.h"
+
+#include <limits>
+
+namespace Track
+{
+
+NearTrack::NearTrack(const Track & track, btVector3 position)
+ : m_track(track)
+{
+ jump_to(position);
+}
+
+NearTrack::~NearTrack()
+{
+}
+
+/** Return true if given face coordinates are on the triangle, false
+ * if they are off of it.
+ */
+bool check_on_face(btScalar s, btScalar t)
+{
+ return (s > 0.0) && (t > 0.0) && (s + t < 1.0);
+}
+
+btScalar NearTrack::move_towards(btVector3 position)
+{
+ best_distance = std::numeric_limits<btScalar>::max();
+ best_face = m_face;
+ best_world_coords = btVector3(std::numeric_limits<btScalar>::max(),
+ std::numeric_limits<btScalar>::max(),
+ std::numeric_limits<btScalar>::max());
+ move_towards_recursive(position);
+ // DEBUG_MESSAGE("Examined " << examined.size() << " triangles.");
+ examined.clear();
+ // Set the data about the best position.
+ m_face = best_face;
+ m_world_coord = best_world_coords;
+ set_info();
+ return best_distance;
+}
+
+void NearTrack::move_towards_recursive(btVector3 position)
+{
+ // Move to the nearest point on the current face.
+ // If it is on the edge, move to the other face on that edge and try
+ // again.
+ // Stop when the nearest point is not on an edge, or is father away than
+ // a point already considered.
+ const MeshFaces::Graph & graph(m_track.get_ai_graph());
+ MeshFaces::FaceGraph face = graph[m_face];
+ m_world_coord = face.find_nearest_point(position);
+ btVector3 face_coord = face.to_face_coords(m_world_coord);
+ btScalar this_distance = position.distance2(m_world_coord);
+ if (this_distance < best_distance)
+ {
+ // an improvement
+ best_face = m_face;
+ best_distance = this_distance;
+ best_world_coords = m_world_coord;
+ }
+ // try recusring.
+ // Include a margin to get things sharing an edge with rounding errors.
+ if (this_distance <= (best_distance + 0.01)
+ && ( face_coord.x() < 0.01
+ || face_coord.y() < 0.01
+ || face_coord.x() + face_coord.y() > 0.99))
+ {
+ // It could be better to look on an adjacent face, so we recurse.
+ // Don't redo this face until we have a result.
+ examined.insert(m_face);
+
+ btVector3 best_world_coord = m_world_coord;
+ // Find connected faces.
+ MeshFaces::Graph::vertex_descriptor best_face = m_face;
+ typedef MeshFaces::Graph::adjacency_iterator AdjacencyIterator;
+ std::pair<AdjacencyIterator, AdjacencyIterator> its;
+ for (its = boost::adjacent_vertices(m_face, graph);
+ its.first != its.second;
+ its.first++)
+ {
+ m_face = *(its.first);
+ // don't recurse to faces already examined.
+ if (examined.find(m_face) == examined.end())
+ {
+ /** This recursive behaviour terminates within a reasonable
+ * time because:
+ * 1) It excludes each face already visited, so cannot loop
+ * and therefore stops, and
+ * 2) Faces that do not share an edge with the edge the point
+ * is stuck on are only visited 1 layer deep unless they
+ * can provide a closer point, and
+ * 3) The number of faces connected to another vertex is at
+ * most 3 in a sane course. It may be more at a jump with
+ * multiple targets to land on.
+ * It should be O(n * log n) with n = triangles crossed.
+ *
+ */
+ move_towards_recursive(position);
+ }
+ }
+ }
+}
+
+btScalar NearTrack::jump_to(btVector3 position)
+{
+ // find the nearest point on the mesh to the given position.
+ const MeshFaces::Graph & graph(m_track.get_ai_graph());
+ btScalar max_distance2 = std::numeric_limits<btScalar>::max();
+ std::pair<MeshFaces::Graph::vertex_iterator, MeshFaces::Graph::vertex_iterator> vits;
+ for (vits = boost::vertices(graph);
+ vits.first != vits.second;
+ vits.first++)
+ {
+ MeshFaces::Graph::vertex_descriptor v_descriptor = *(vits.first);
+ MeshFaces::FaceGraph face = graph[v_descriptor];
+ // Find the nearest point to plane on this triangle
+ btVector3 nearest_point = face.find_nearest_point(position);
+ btScalar distance2 = nearest_point.distance2(position);
+ // Is it the best so far?
+ if (distance2 < max_distance2)
+ {
+ max_distance2 = distance2;
+ // remember information about this face.
+ m_world_coord = nearest_point;
+ m_face = v_descriptor;
+ }
+ }
+ // find other information about the attachment point.
+ set_info();
+}
+
+btVector3 NearTrack::get_position() const
+{
+ return m_world_coord;
+}
+
+MeshFaces::Graph::vertex_descriptor NearTrack::get_face_descriptor() const
+{
+ return m_face;
+}
+
+NearTrack::AttachSource NearTrack::get_object_type() const
+{
+ return m_object_type;
+}
+
+unsigned long int NearTrack::get_object_name() const
+{
+ return m_object_name;
+}
+
+void NearTrack::set_info()
+{
+ const MeshFaces::Graph & graph(m_track.get_ai_graph());
+ MeshFaces::FaceGraph face = graph[m_face];
+ /** @todo Set m_object_coord correctly.
+ * It would make it easier to move correctly when the object it is
+ * attached to is moved.
+ */
+ m_object_coord = btVector3(0.0, 0.0, 0.0);
+ m_object_type = face.is_edge? AS_EDGE : AS_VERTEX;
+ m_object_name = face.object_name;
+ btVector3 face_coord = face.to_face_coords(m_world_coord);
+ m_face_s = m_object_coord.x();
+ m_face_t = m_object_coord.y();
+}
+
+} // namespace Track
Added: trunk/libtrack/NearTrack.h
===================================================================
--- trunk/libtrack/NearTrack.h (rev 0)
+++ trunk/libtrack/NearTrack.h 2010-02-17 03:49:29 UTC (rev 252)
@@ -0,0 +1,145 @@
+/** @file libtrack/NearTrack.h
+ * @brief Declare the Track::NearTrack class.
+ * @author James Legg
+ */
+/* Copyright © 2010 James Legg.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+*/
+
+#ifndef LIBTRACK_NEAR_TRACK_H
+#define LIBTRACK_NEAR_TRACK_H
+
+#include "Track.h"
+#include <set>
+
+namespace Track
+{
+
+/** An object which has an attachment point to an AI mesh.
+ */
+class NearTrack
+{
+ public:
+ /** Make an object positioned on a track.
+ * @param track The track to constrain too. Cannot be changed.
+ * @param position The nearest world space coordinates to the desired
+ * starting position.
+ */
+ NearTrack(const Track & track, btVector3 position);
+
+ virtual ~NearTrack();
+
+ /** Move the attach point closer to a position.
+ * Requires an up to date AI mesh in the track.
+ *
+ * The path taken will be continuous. It won't move to the nearest
+ * point if the nearest point is not on a reasonable path from the
+ * current location.
+ *
+ * @param position The world coordinate to move towards.
+ * @return square of the distance between the provided position and
+ * the found point.
+ */
+ btScalar move_towards(btVector3 position);
+
+ /** Set the attach point to the closest point on the AI navigation mesh.
+ * This is much slower than move_towards(btVector3). Use that if you
+ * can help it.
+ *
+ * Time complexity is O(n), where n is the number of triangles in the
+ * ai navigation mesh.
+ *
+ * @param position. The world coordinate to jump to.
+ * @return square of the distance between the provided position and
+ * the found point.
+ */
+ btScalar jump_to(btVector3 position);
+
+ /** Return the position in world space.
+ */
+ btVector3 get_position() const;
+
+ /** Return the face the position is on.
+ */
+ MeshFaces::Graph::vertex_descriptor get_face_descriptor() const;
+
+ /// The types of objects Track::NearTrack can attach to.
+ enum AttachSource
+ {
+ AS_VERTEX, ///< Attachted to a Track::PathVertex
+ AS_EDGE, ///< Attached to a Track::PathEdge
+ AS_UNKOWN ///< Not correctly attached to anything.
+ };
+
+ /** Return the type of object the point is attached to.
+ */
+ AttachSource get_object_type() const;
+
+ /** Get the identifier for the object the point is attached to.
+ * Useful when combined with get_source_type.
+ */
+ unsigned long int get_object_name() const;
+
+ protected:
+ /** Relative coordinates for edge or vertex attached to.
+ * For an edge, this is distorted to lie along the edge.
+ * The y coordinate for an edge is between 0 (start) and 1 (finish) of
+ * the edge. The x and z coordinates are used like the edge's meshes.
+ *
+ * For a vertex, it is in the vertex's local space.
+ */
+ btVector3 m_object_coord;
+
+ /** The type of object the Track::NearTrack is attached to.
+ * May Unkown if the relavent object is deleted from the track.
+ */
+ AttachSource m_object_type;
+
+ unsigned long int m_object_name;
+
+ /** World coordinates.
+ * May become outdated when the track changes.
+ */
+ btVector3 m_world_coord;
+
+ /** AI mesh face attached to.
+ * Will be invalid when the track changes.
+ */
+ MeshFaces::Graph::vertex_descriptor m_face;
+
+ /** Coordinates in the direction of m_face's fv1 -> fv2 edge.
+ * Will be invalid when the track changes.
+ */
+ btScalar m_face_s;
+
+ /** Coordinates in the direction of m_face's fv1 -> fv3 edge.
+ * Will be invalid when the track changes.
+ */
+ btScalar m_face_t;
+
+ /// Reference to the track which the object is in.
+ const Track & m_track;
+
+ /// The vertices examined in move_towards().
+ std::set<MeshFaces::Graph::vertex_descriptor> examined;
+ /// The lowest distance reached in move_towards().
+ btScalar best_distance;
+ /// The face with the lowest distance reached in move_towards().
+ MeshFaces::Graph::vertex_descriptor best_face;
+ /// The world coordianates of the solution with the lowest distance reached by move_towards().
+ btVector3 best_world_coords;
+
+ /** Set m_object_coord m_object_name m_object_type, m_face_s/t from m_face.
+ * Finds relavent information from the graph face.
+ */
+ void set_info();
+
+ void move_towards_recursive(btVector3 position);
+};
+
+} // namespace Track
+
+#endif // LIBTRACK_NEAR_TRACK_H
Modified: trunk/libtrack/path/PathEdge.cpp
===================================================================
--- trunk/libtrack/path/PathEdge.cpp 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/libtrack/path/PathEdge.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -2,7 +2,7 @@
* @brief Implement the Track::PathEdgeEnd class.
* @author James Legg
*/
-/* Copyright © 2009 James Legg.
+/* Copyright © 2009, 2010 James Legg.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
@@ -315,7 +315,9 @@
PieceDistortion transform(*this, i,
segment->get_length(),
segment->get_minimum_y());
- mesh |= segment->get_ai_mesh().get_distorted_faces(transform);
+ MeshFaces faces = segment->get_ai_mesh().get_distorted_faces(transform);
+ faces.set_source(true, get_name());
+ mesh |= faces;
}
}
Modified: trunk/libtrack/path/PathVertex.cpp
===================================================================
--- trunk/libtrack/path/PathVertex.cpp 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/libtrack/path/PathVertex.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -2,7 +2,7 @@
* @brief Implement the Track::PathVertex class.
* @author James Legg
*/
-/* Copyright © 2009 James Legg.
+/* Copyright © 2009, 2010 James Legg.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
@@ -282,7 +282,9 @@
void PathVertex::add_ai_faces(MeshFaces & mesh) const
{
btTransform transform(angle, position);
- mesh |= segment->get_ai_mesh().get_distorted_faces(transform);
+ MeshFaces faces = segment->get_ai_mesh().get_distorted_faces(transform);
+ faces.set_source(false, get_name());
+ mesh |= faces;
}
AxisAlignedBoundingBox PathVertex::get_bounds() const
Modified: trunk/racer/Engine/GameObjects/Car.cpp
===================================================================
--- trunk/racer/Engine/GameObjects/Car.cpp 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/racer/Engine/GameObjects/Car.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -2,7 +2,7 @@
* @brief Implement the Engine::GameObjects::Car class.
* @author James Legg
*/
-/* Copyright © 2009 James Legg.
+/* Copyright © 2009, 2010 James Legg.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
@@ -90,7 +90,8 @@
Car::Car(Physics::World & world, btTransform start, InputDevice * input_device,
unsigned int car_model, const btVector3 & plane_normal,
const btScalar & plane_distance, const btVector3 & start_point)
- : world(world),
+ : NearTrack(world.get_track(), start.getOrigin())
+ , world(world),
input_device(input_device),
force(0, 0, 0),
torque(0, 0, 0),
@@ -209,6 +210,27 @@
glColor3ub(255, 255, 255);
}
glPopMatrix();
+#ifndef NDEBUG
+ glDisable(GL_TEXTURE_2D);
+ glBegin(GL_LINE_STRIP);
+ glVertex3f(get_position().x(), get_position().y(), get_position().z());
+ glVertex3f(transform.getOrigin().x(),
+ transform.getOrigin().y(),
+ transform.getOrigin().z());
+ glEnd();
+ glBegin(GL_LINES);
+ glColor3f(0,1,0);
+ const Track::MeshFaces::Graph & graph = m_track.get_ai_graph();
+ const btVector3 *v = graph[get_face_descriptor()].vertex_positions;
+ glVertex3f(v[0].x(), v[0].y(), v[0].z());
+ glVertex3f(v[1].x(), v[1].y(), v[1].z());
+ glColor3f(0,0,1);
+ glVertex3f(v[0].x(), v[0].y(), v[0].z());
+ glVertex3f(v[2].x(), v[2].y(), v[2].z());
+ glEnd();
+ glColor3f(1,1,1);
+ glEnable(GL_TEXTURE_2D);
+#endif
}
void Car::take_input(InputReport & report)
@@ -251,6 +273,8 @@
btTransform rotation_transform(transform);
rotation_transform.setOrigin(btVector3(0, 0, 0));
+ move_towards(transform.getOrigin());
+
// passed start finish line?
bool new_infront_of_start = transform.getOrigin().dot(plane_normal) + plane_distance > 0;
if (new_infront_of_start != infront_of_start)
Modified: trunk/racer/Engine/GameObjects/Car.h
===================================================================
--- trunk/racer/Engine/GameObjects/Car.h 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/racer/Engine/GameObjects/Car.h 2010-02-17 03:49:29 UTC (rev 252)
@@ -2,7 +2,7 @@
* @brief Declare the Engine::GameObjects::Car class.
* @author James Legg
*/
-/* Copyright © 2009 James Legg.
+/* Copyright © 2009, 2010 James Legg.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
@@ -16,6 +16,7 @@
#include <libtrack/AABBDrawable.h>
#include <libtrack/Texture.h>
#include <libtrack/Mesh/BulletMesh.h>
+#include <libtrack/NearTrack.h>
#include "../Physics/World.h"
#include "../Physics/TickObserver.h"
@@ -34,6 +35,7 @@
class Car
: public Track::AABBDrawable
, public Physics::TickObserver
+ , private Track::NearTrack
{
Car(Car & car);
Car & operator=(Car & car);
Modified: trunk/racer/Engine/GameScene.cpp
===================================================================
--- trunk/racer/Engine/GameScene.cpp 2010-02-13 04:25:52 UTC (rev 251)
+++ trunk/racer/Engine/GameScene.cpp 2010-02-17 03:49:29 UTC (rev 252)
@@ -2,7 +2,7 @@
* @brief Implement the Engine::GameScene class.
* @author James Legg
*/
-/* Copyright © 2009 James Legg.
+/* Copyright © 2009, 2010 James Legg.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
@@ -408,7 +408,6 @@
const Track::MeshFaces::Graph & graph = track.get_ai_graph();
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
- glColor3ub(255, 0, 0);
glBegin(GL_LINES);
typedef boost::graph_traits<Track::MeshFaces::Graph>::edge_iterator EdgeIterator;
std::pair<EdgeIterator, EdgeIterator> edge_range;
@@ -418,6 +417,7 @@
{
const btVector3 & source = graph[boost::source(*(edge_range.first), graph)].face_centre;
const btVector3 & target = graph[boost::target(*(edge_range.first), graph)].face_centre;
+ glColor3f(1.0, graph[boost::source(*(edge_range.first), graph)].fv1.texture_coord_u / 1000.0, 0);
glVertex3f(source.x(), source.y(), source.z());
glVertex3f(target.x(), target.y(), target.z());
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|