Ground.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for Physic simulation.
//
// Author(s)    : - Jean-luc CHARLES I2M-DuMAS/ENSAM Talence France
//                  <jean-luc.charles@ensam.eu>
//                - Damien ANDRE     SPCTS/ENS Ceramique industrielle, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jeremie GIRARDOT I2M-DuMAS/ENSAM Talence France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert    LAMIH/UVHC Valenciennes France
//                  <cedric.hubert@univ-valenciennes.fr>
//                - Ivan IORDANOFF   I2M-DuMAS-MPI/ENSAM Talence France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2016 JL. CHARLES, D. ANDRE, I. IORDANOFF, J. GIRARDOT
//
//
//
//
//
// 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.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _libPhysic_Ground_tpp_
#define _libPhysic_Ground_tpp_
 
#include <string>
 
#include "GranOO3/Core/SetOf.hpp"
#include "GranOO3/Core/NeedSetOf.hpp"
#include "GranOO3/Core/Base.hpp"
#include "GranOO3/Core/PropClass.hpp"
 
#include "GranOO3/Shape/Base.hpp"
#include "GranOO3/Shape/Volume.hpp"
#include "GranOO3/Shape/Surface.hpp"
#include "GranOO3/Core/XmlParser.hpp"
 
 
namespace GranOO3
{
  namespace Physic
  {
    class Node;
 
    // A ground is simply a shape inserted in a simulation.
    // A ground is like a body without : force, torque, velocity or acceleration.
    // This is a "passive" body. Each ground have a specific ID
    // A ground may be a surface or a volume
 
    class Ground : public Core::Base, public Core::Register<Ground> {
 
      GRANOO_CLASS(Physic::Ground, Core::Base);
      GRANOO_CLASS_DEFAULT_COLOR(.2, .8, .4, .2);
 
    public:
      static Ground& get(std::string);
      static bool exist(std::string);
      static Ground& glob(const std::string& id);
      static Ground* new_object(const TiXmlElement* el);
 
    public:
      //CONSTRUCTORS & DESTRUCTORS
      Ground(const std::string& id, const Geom::Point & p, const Geom::Quaternion& q);
      virtual ~Ground();
 
      //INTERNAL USE (Not documented)
      virtual void read_xml_element(const TiXmlElement* el);
      virtual void add_glob(const std::string&) = 0;
 
      //USEFULL
      virtual std::string info() const;
      virtual std::string shape_class_ID() const = 0;
 
      //ACCESSORS
      GRANOO_ACCESS (ID              , std::string     , _ID             );
      GRANOO_ACCESS (center          , Geom::Point     , _center         );
      GRANOO_ACCESS (position        , Geom::Vector    , _position       );
      GRANOO_ACCESS (quaternion      , Geom::Quaternion, _quat           );
      GRANOO_ACCESS (force           , Geom::Vector    , _force          );
      GRANOO_ACCESS (contact_force   , Geom::Vector    , _contact_force  );
      GRANOO_ACCESS (torque          , Geom::Vector    , _torque         );
      GRANOO_ACCESS (linear_velocity , Geom::Vector    , _linear_velocity);
      GRANOO_ACCESS (angular_velocity, Geom::Vector    , _angular_vel    );
      GRANOO_ACCESS_REF_CONST (local_frame, Geom::Frame, _frame          );
 
      // IO
      virtual std::ostream& write_ascii(std::ostream& out) const;
      virtual std::istream& read_ascii(std::istream& in);
      virtual std::ostream& export_to_povray(std::ostream& out) const;
 
      // SHAPE MANAGEMENT
      virtual Shape::Base& to_base_shape()             = 0;
      virtual const Shape::Base& to_base_shape() const = 0;
 
      virtual Shape::Volume& to_volume_shape();
      virtual const Shape::Volume& to_volume_shape() const;
 
      virtual Shape::Surface& to_surface_shape();
      virtual const Shape::Surface& to_surface_shape() const;
 
      // FORCE COMPUTATION
      void apply_force(const Geom::Vector&);
      void apply_force_at(const Geom::Vector&, const Geom::Point&);
      void clear_force();
      void apply_torque(const Geom::Vector&);
      void clear_torque();
 
      // incremental_move() applies an incremental linear and angular displacement
      // from the current velocity values (without any acceleration) 
      void incremental_move();
 
      
      Geom::Vector get_linear_velocity_at(const Geom::Point&) const;
 
      // For contact management, it always return false
      bool is_interact_with(const Node &) const;
 
    private:
      Ground(const Ground  &);                 //Not allowed
      Ground & operator=(const Ground  &); //Not allowed
 
      //SERIALIZATION
      friend class boost::serialization::access;
      template<class Archive> void save(Archive &, const unsigned int) const;
      template<class Archive> void load(Archive &, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
    protected:
      Ground();
 
    protected:
      std::string      _ID;
      Geom::Point      _center;
      Geom::Vector&    _position;
      Geom::Quaternion _quat;
      Geom::Frame      _frame;
      Geom::Vector     _force;
      Geom::Vector     _contact_force;
      Geom::Vector     _torque;
      Geom::Vector     _linear_velocity;
      Geom::Vector     _angular_vel;
    };
 
    inline bool
    Ground::is_interact_with(const Node &) const {
      return false;
    }
 
    inline Ground& Ground::get(std::string id) {
      Core::SetOf< Ground >& set = Core::SetOf<Ground>::get_global_set();
      for (unsigned int i = 0; i<set.size(); ++i) {
        if (set[i]->get_ID()==id)
          return *set[i];
      }
      UserAssert(0, "can't find Ground named " + id);
      return *set[0];
    }
 
    inline bool Ground::exist(std::string id) {
      Core::SetOf< Ground >& set = Core::SetOf< Ground >::get_global_set();
      for (unsigned int i = 0; i<set.size(); ++i) {
        if (set[i]->get_ID()==id)
          return true;
      }
      return false;
    }
 
    
    inline Shape::Volume&
    Ground::to_volume_shape() {
      SafeModeAssert(to_base_shape().is_volume() == true, "Can't cast to Volume");
      return static_cast<Shape::Volume&>(to_base_shape());
    }
 
    inline const Shape::Volume&
    Ground::to_volume_shape() const {
      SafeModeAssert(to_base_shape().is_volume() == true, "Can't cast to Volume");
      return static_cast<const Shape::Volume&>(to_base_shape());
    }
 
    inline Shape::Surface&
    Ground::to_surface_shape() {
      SafeModeAssert(to_base_shape().is_surface() == true, "Can't cast to surface");
      return static_cast<Shape::Surface&>(to_base_shape());
    }
 
    inline const Shape::Surface&
    Ground::to_surface_shape() const {
      SafeModeAssert(to_base_shape().is_surface() == true, "Can't cast to surface");
      return static_cast<const Shape::Surface&>(to_base_shape());
    }
 
    
    inline std::string
    Ground::info() const {
      std::ostringstream os;
 
      os << "**Ground**" << '\n'
         << "id        : " << _ID << '\n'
         << "center    : " << _center << '\n'
         << "quaternion: " << _quat << '\n';
      return os.str();
    }
 
    template<class Archive>
    void
    Ground::save(Archive& ar, const unsigned int v) const {
      ar << boost::serialization::base_object<Core::Base>(*this);
      ar << _ID;
      ar << _center;
      ar << _quat;
      ar << _force;
      ar << _torque;
      ar << _linear_velocity;
      ar << _angular_vel;
    }
 
    template<class Archive>
    void
    Ground::load(Archive& ar, const unsigned int v) {
      ar >> boost::serialization::base_object<Core::Base>(*this);
      std::string& id = const_cast<std::string&>(_ID);
      ar >> id;
      ar >> _center;
      ar >> _quat;
      ar >> _force;
      ar >> _torque;
      ar >> _linear_velocity;
      ar >> _angular_vel;
 
      local_frame().update_glMatrix();
      id = Core::SetOfManager::get().get_SerializationPrefix() + id +
           Core::SetOfManager::get().get_SerializationSuffix();
    }
 
  }
}
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::Physic::Ground, 0)
 
namespace GranOO3
{
  GRANOO_CLASS_DECLARE_TPL(Physic::Ground);
}
 
 
 
#endif