Block.h

Go to the documentation of this file.

/*+-------------------------------------------------------------------------+
  |                       Multiblock simulator (libmvsim)                 |
  |                                                                         |
  | Copyright (C) 2014  Jose Luis Blanco Claraco (University of Almeria)    |
  | Copyright (C) 2017  Borys Tymchenko (Odessa Polytechnic University)     |
  | Distributed under GNU General Public License version 3                  |
  |   See <http://www.gnu.org/licenses/>                                    |
  +-------------------------------------------------------------------------+ */

#pragma once

#include <mvsim/basic_types.h>
#include <mvsim/VisualObject.h>
#include <mvsim/Simulable.h>
#include <mvsim/ClassFactory.h>

#include <Box2D/Dynamics/b2World.h>
#include <Box2D/Dynamics/b2Body.h>
#include <Box2D/Collision/Shapes/b2PolygonShape.h>
#include <Box2D/Dynamics/b2Fixture.h>
#include <Box2D/Dynamics/Joints/b2FrictionJoint.h>

#include <mrpt/poses/CPose2D.h>
#include <mrpt/opengl/CSetOfObjects.h>
#include <mrpt/opengl/CSetOfLines.h>
#include <mrpt/utils/TColor.h>

namespace mvsim
{
class Block : public VisualObject, public Simulable
{
   public:
        static Block* factory(
                World* parent, const rapidxml::xml_node<char>* xml_node);
        static Block* factory(World* parent, const std::string& xml_text);

        static void register_block_class(const rapidxml::xml_node<char>* xml_node);

        // ------- Interface with "World" ------
        virtual void simul_pre_timestep(const TSimulContext& context);
        virtual void simul_post_timestep(const TSimulContext& context);
        virtual void apply_force(
                double fx, double fy, double local_ptx = 0.0, double local_pty = 0.0);

        void simul_post_timestep_common(const TSimulContext& context);

        virtual void create_multibody_system(b2World* world);

        virtual float getMaxBlockRadius() const { return m_max_radius; }
        virtual double getMass() const { return m_mass; }
        b2Body* getBox2DBlockBody() { return m_b2d_block_body; }
        mrpt::math::TPoint2D getBlockCenterOfMass() const
        {
                return m_block_com;
        }  

        const mrpt::math::TPose3D& getPose() const
        {
                return m_q;
        }  

        void setPose(const mrpt::math::TPose3D& p) const
        {
                const_cast<mrpt::math::TPose3D&>(m_q) = p;
        }  


        mrpt::poses::CPose2D getCPose2D() const;  

        const vec3& getVelocity() const { return m_dq; }
        vec3 getVelocityLocal() const;

        const std::string& getName() const { return m_name; }
        const mrpt::math::TPolygon2D& getBlockShape() const { return m_block_poly; }
        void setBlockIndex(size_t idx) { m_block_index = idx; }
        size_t getBlockIndex() const { return m_block_index; }
        virtual void gui_update(mrpt::opengl::COpenGLScene& scene);

   protected:
        // Protected ctor for class factory
        Block(World* parent);

        std::string
                m_name;  
        size_t m_block_index;  


        b2Body* m_b2d_block_body;
        std::vector<b2FrictionJoint*> m_friction_joints;

        mrpt::math::TPose3D
                m_q;  
        vec3 m_dq;  


        // Block info:
        double m_mass;
        mrpt::math::TPolygon2D m_block_poly;
        double m_max_radius;  

        double m_block_z_min, m_block_z_max;
        mrpt::utils::TColor m_block_color;
        mrpt::math::TPoint2D m_block_com;  

        double m_lateral_friction;  
        double m_ground_friction;  
        double m_restitution;  

        void updateMaxRadiusFromPoly();

        // Box2D elements:
        b2Fixture* m_fixture_block;

   private:
        void internal_gui_update_forces(
                mrpt::opengl::COpenGLScene&
                        scene);  

        mrpt::opengl::CSetOfObjects::Ptr m_gl_block;
        mrpt::opengl::CSetOfLines::Ptr m_gl_forces;
        std::mutex m_force_segments_for_rendering_cs;
        std::vector<mrpt::math::TSegment3D> m_force_segments_for_rendering;

};  // end Block
}