Body.h

Go to the documentation of this file.

#ifndef PMPL_BODY_H_
#define PMPL_BODY_H_
 
#include "Geometry/GMSPolyhedron.h"
#include "Utilities/MPUtils.h"
 
#include "Transformation.h"
 
#include "glutils/color.h"
 
#include <memory>
#include <set>
#include <string>
#include <vector>
 
using namespace mathtool;
 
class CollisionDetectionMethod;
class Connection;
class MultiBody;
class XMLNode;
 
 
class Body {
 
  public:
 
 
    enum class Type {
      Planar,     
      Volumetric, 
      Fixed,      
      Joint       
    };
 
    enum class MovementType {
      Fixed,        
      Joint,        
      Rotational,   
      Translational 
    };
 
 
    Body(MultiBody* const _owner, const size_t _index = 0);
 
    Body(MultiBody* const _owner, XMLNode& _node);
 
    Body(const Body& _other); 
    Body(Body&& _other);      
 
    ~Body();
 
 
    Body& operator=(const Body& _other);  
    Body& operator=(Body&& _other);       
 
 
    void Validate() const;
 
 
    MultiBody* GetMultiBody() const noexcept;
 
    void SetMultiBody(MultiBody* const _owner) noexcept;
 
    size_t GetIndex() const noexcept;
 
    double GetWeight() const;
 
    const std::string& Label() const noexcept;
 
    bool IsBase() const noexcept;
 
    void SetBodyType(const Body::Type _type) noexcept;
 
    Body::Type GetBodyType() const noexcept;
 
    void SetMovementType(const MovementType _type) noexcept;
 
    MovementType GetMovementType() const noexcept;
 
 
    double GetMass() const;
 
    const Matrix3x3& GetMoment() const;
 
 
    void SetPolyhedron(GMSPolyhedron&& _poly);
 
    const GMSPolyhedron& GetPolyhedron() const;
 
    const GMSPolyhedron& GetWorldPolyhedron() const;
 
    const GMSPolyhedron& GetBoundingBox() const;
 
    GMSPolyhedron GetWorldBoundingBox() const;
 
 
    void MarkDirty();
 
    void Configure(const Transformation& _transformation);
 
    const Transformation& GetWorldTransformation() const;
 
 
    size_t ForwardConnectionCount() const noexcept;
 
    size_t BackwardConnectionCount() const noexcept;
 
    size_t AdjacencyConnectionCount() const noexcept;
 
    Connection& GetForwardConnection(const size_t _index) const noexcept;
 
    Connection& GetBackwardConnection(const size_t _index) const noexcept;
 
    Connection& GetAdjacencyConnection(const size_t _index) const noexcept;
 
    Connection* GetConnectionTo(const Body* const _other) const noexcept;
 
    bool IsAdjacent(const Body* const _otherBody) const;
 
    bool SameParent(const Body* const _otherBody) const;
 
    void LinkForward(Connection* const _c);
 
    void LinkBackward(Connection* const _c);
 
    void LinkAdjacency(Connection* const _c);
 
    void Unlink(Connection* const _c);
 
 
    static std::string m_modelDataDir; 
 
    const std::string& GetFileName() const;
 
    std::string GetFilePath() const;
 
    void ReadGeometryFile(const std::string& _filename);
 
    void ReadGeometryFile(
        GMSPolyhedron::COMAdjust _comAdjust = GMSPolyhedron::COMAdjust::None);
 
    void Read(std::istream& _is, CountingStreamBuffer& _cbs);
 
 
    const glutils::color& GetColor() const;
 
    void SetColor(const glutils::color& _c);
 
    bool IsTextureLoaded() const;
 
    const std::string& GetTexture() const;
 
 
  private:
 
 
    void ComputeMomentOfInertia() const;
 
    void ComputeBoundingBox() const;
 
    const Transformation& FetchBaseTransform() const noexcept;
 
    const Transformation& FetchLinkTransform() const noexcept;
 
    const Transformation& ComputeWorldTransformation(std::set<size_t>& _visited)
        const;
 
 
    MultiBody* m_multibody{nullptr};         
    size_t m_index{0};                       
    std::string m_label;                     
    std::string m_filename;                  
 
    Body::Type m_bodyType;                   
    MovementType m_movementType;             
 
    GMSPolyhedron m_polyhedron;              
    GMSPolyhedron m_boundingBox;             
 
    Transformation m_transform;         
    mutable bool m_transformCached{false};    
 
    mutable GMSPolyhedron m_worldPolyhedron;     
    mutable bool m_worldPolyhedronCached{false}; 
 
    double m_mass{1};                        
    double m_weight{0.0};                    
    Matrix3x3 m_moment;                      
    GMSPolyhedron::COMAdjust m_comAdjust{GMSPolyhedron::COMAdjust::COM};
 
    std::vector<Connection*> m_forwardConnections;  
    std::vector<Connection*> m_backwardConnections; 
    std::vector<Connection*> m_adjacencyConnections;
 
    const Transformation& (Body::*m_transformFetcher)(void) const noexcept = nullptr;
 
 
    glutils::color m_color{glutils::color::blue}; 
    std::string m_textureFile;                    
 
 
};
 
/*-------------------------------- I/O Helpers -------------------------------*/
 
std::ostream& operator<<(std::ostream& _os, const Body& _body);
 
#endif