MeshFaces.h

Go to the documentation of this file.

/* 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
    (at your option) any later version.
*/
#ifndef LIBTRACK_MESHFACES_H_
#define LIBTRACK_MESHFACES_H_

#include <vector>
#include <set>
#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
 * including boost graph library headers.
 * We don't need the hash-based storage selectors anyway, so turn them off.
 */
#define BOOST_NO_HASH
#include <boost/graph/adjacency_list.hpp>
#undef BOOST_NO_HASH

#include "../AxisAlignedBoundingBox.h"
#include "../Geometry.h"

namespace Track
{

class MeshFaces
    :   virtual public AABBBounded
{
public:
    MeshFaces(std::istream & source);
    
    MeshFaces(std::string & filename);
    
    MeshFaces();
    virtual ~MeshFaces();
    
    struct FaceVertex
    {
        FaceVertex();
        FaceVertex(std::size_t vertex_index);
        std::size_t vertex_index;
        btVector3 normal;
        float texture_coord_u;
        float texture_coord_v;
    };
    
    struct Face
    {
        Face();
        Face(std::size_t v1, std::size_t v2, std::size_t v3);
        Face (const FaceVertex & fv1, const FaceVertex & fv2,
              const FaceVertex & fv3);
        FaceVertex fv1;
        FaceVertex fv2;
        FaceVertex fv3;
        
        bool is_edge;
        unsigned long int object_name;
    };
    
    // extra information about a face useful in the graph
    struct FaceGraph : public Face
    {
        FaceGraph() {};
        FaceGraph(const Face & face);
        btVector3 face_centre;
        btVector3 face_normal;
        btVector3 vertex_positions[3];
        btVector3 edges[2];
        
        btMatrix3x3 world_to_face;
        btMatrix3x3 face_to_world;
        
        Plane edge_planes[3];
        Line edge_line_segments[3];
        Plane face_plane;
        
        void set_conversions();
        
        btVector3 to_face_coords(btVector3 world_coords) const;
        btVector3 to_world_coords(btVector3 face_coords) const;
        btVector3 find_nearest_point(btVector3 position) const;
    };
    
    struct Edge
    {
        Edge() {};
        Edge(std::size_t v1, std::size_t v2);
        std::size_t v1;
        std::size_t v2;
        bool operator< (Edge o) const;
    };
    
    struct EdgeGraph : public Edge
    {
        EdgeGraph()
        {};
        
        EdgeGraph(std::size_t v1, std::size_t v2)
            :   Edge(v1, v2)
        {};
        
        btScalar length;
        btVector3 v2_pos;
        btVector3 v1_pos;
    };
    
    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                                 FaceGraph, EdgeGraph> Graph;
    
    struct FaceEdgePointers
    {
        FaceEdgePointers() {};
        FaceEdgePointers(Face * face, FaceVertex * source,
                         FaceVertex * target, btScalar length)
            :   face(face)
            ,   source(source)
            ,   target(target)
            ,   length(length)
        {};
        Face * face;
        FaceVertex * source;
        FaceVertex * target;
        btScalar length;
    };
    
    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                                 btVector3, FaceEdgePointers> VertexGraph;

public:
    btVector3 get_vertex_pos(std::size_t index) const;
    
    void add_vertex(const btVector3 & position);
    
    void add_normal(const btVector3 & normal);
    
    void add_texture_coord(const btVector3 & normal);
    
    std::size_t get_num_vertices() const;
    
    const Face & get_face(std::size_t index) const;
    
    std::vector<Edge> get_edges_for_face(std::size_t face) const;
    
    void add_face(std::size_t v1, std::size_t v2, std::size_t v3);
    
    void add_face(std::size_t v1, std::size_t n1, std::size_t v2, std::size_t n2, std::size_t v3, std::size_t n3);
    
    void add_face(Face face);
    
    std::size_t get_number_of_faces() const;
    
    Graph get_connectivity() const;
    
    VertexGraph get_vertex_graph();
     
    void copy_faces(const MeshFaces & other);
    
    void add_faces(btTriangleMesh & shape) const;
    
    virtual AxisAlignedBoundingBox get_bounds() const;
    
    void merge_doubles(btScalar distance2 = 1.0 / 32.0);
    
    void operator|=(const MeshFaces & source);
    
    void set_source(bool is_edge, unsigned long int object_name);
protected:
    void load_from_stream(std::istream & source);
    
    void add_edge(std::size_t v1, std::size_t v2, std::size_t face_index,
                  std::map<EdgeGraph, std::size_t> & edge_to_face,
                  std::vector<std::pair<std::size_t, std::size_t> > & graph_edges,
                  std::vector<EdgeGraph> & edge_properties) const;
    
    std::vector<btVector3> vertices_position;
    
    std::vector<Face> faces;
    
    AxisAlignedBoundingBox bounds;
};

}

#endif /*LIBTRACK_MESHFACES_H_*/

---

Generated at Mon Sep 6 00:41:11 2010 by Doxygen version 1.4.7 for Racer version svn335.