PathEdge.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_PATH_PATH_EDGE_H
#define LIBTRACK_PATH_PATH_EDGE_H

#include <ostream>
#include <istream>
#include <vector>

#include <boost/shared_ptr.hpp>

#include <LinearMath/btScalar.h>
#include <LinearMath/btTransform.h>
#include <BulletCollision/CollisionShapes/btTriangleMesh.h>

#include "../UniqueIdentifier.h"
#include "../edit_base/Selectable.h"
#include "../Segment.h"
#include "../Mesh/DrawableMesh.h"

#include "PathEdgeEnd.h"
#include "PathVertex.h"
#include "../AxisAlignedBoundingBox.h"
#include "../AABBDrawable.h"
#include "../TrackAttachment.h"
#include "../edit_base/TrackAttachmentHandle.h"

namespace Track
{

class Path;

class PathEdge
    :   public UniqueIdentifier
    ,   public EditAssist::Selectable
    ,   public AABBDrawable
{
    friend std::ostream & operator<<(std::ostream & destination,
                                     const PathEdge & path_edge);
    friend AxisAlignedBoundingBox & operator|=(AxisAlignedBoundingBox & box,
                                               const PathEdge & path_edge);
public:
    PathEdge(const Theme & theme);
    PathEdge(std::istream & source, const Theme & theme);
    virtual ~PathEdge();
protected:
    const unsigned int file_version;
    const Theme & theme;
public:
    std::size_t segment_index;
    const Segment * segment;
    
    PathEdgeEnd start;
    PathEdgeEnd finish;
    
    DrawableMesh::RenderMode render_mode;
    
    
    void update(std::size_t start_vertex_name,
                std::size_t finish_vertex_name,
                const Path * graph);
    
    void update();
    
    btScalar get_length() const;
    
    unsigned int get_number_of_repetions() const;
    
    btTransform get_transform(btScalar position) const;
    
    const boost::shared_ptr<DrawableMesh> get_graphics_mesh(std::size_t index) const;
    
    virtual bool is_here(btVector3 start, btVector3 stop, btScalar radius) const;
    
    btScalar get_nearest_s(btVector3 start, btVector3 stop) const;
    
    const EditAssist::ControlPoint * get_control_point_here(btVector3 start_pos, btVector3 stop_pos, btScalar radius) const;
    
    void draw_control_points() const;
    
    std::size_t get_start_vertex_name();
    
    std::size_t get_finish_vertex_name();
    
    void add_collision_faces(btTriangleMesh & shape) const;
    void add_floor_faces(btTriangleMesh & shape) const;
    void add_ai_faces(MeshFaces & mesh) const;
    
    virtual AxisAlignedBoundingBox get_bounds() const;
    virtual void draw() const;
    virtual void conditional_draw(const OcclusionTester & occlusion_tester) const;
    void draw_attachments() const;
    void make_cache() const;
    
    void insert_attachment(boost::shared_ptr<TrackAttachment> attachment);
    void remove_attachment(std::size_t attachment_name);
    const std::vector<boost::shared_ptr<TrackAttachment> > & get_attachments() const;
    const TrackAttachment & get_attachment(std::size_t attachment_name) const;
    void set_attachment(std::size_t attachment_name, const TrackAttachment & attachment);
protected:
    std::vector<boost::shared_ptr<TrackAttachment> > m_attachments;
    std::vector<boost::shared_ptr<EditAssist::TrackAttachmentHandle> > m_attachment_handles;
    btScalar length;
    unsigned int number_of_repetions;
    std::vector<boost::shared_ptr<DrawableMesh> > meshes;
    const Path * path;
    std::size_t start_vertex_index;
    std::size_t finish_vertex_index;
    AxisAlignedBoundingBox bounds;
    AxisAlignedBoundingBox graphics_bounds;
    MeshFaces m_nav_mesh;
    MeshFaces::Graph m_navigation_graph;
    
    void recreate_attachment_handles();
};

std::ostream & operator<<(std::ostream & destination,
                          const PathEdge & path_edge);

AxisAlignedBoundingBox & operator|=(AxisAlignedBoundingBox & box,
                                    const PathEdge & path_edge);

}

#endif //LIBTRACK_PATH_PATH_EDGE_H

---

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