CSetOfTriangles.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef opengl_CSetOfTriangles_H
#define opengl_CSetOfTriangles_H

#include <mrpt/opengl/CRenderizableDisplayList.h>
#include <mrpt/math/geometry.h>

namespace mrpt
{
namespace opengl
{
/** A set of colored triangles.
  *  This class can be used to draw any solid, arbitrarily complex object
 * (without textures).
  *  \sa opengl::COpenGLScene, CSetOfTexturedTriangles
  * \ingroup mrpt_opengl_grp
  */
class CSetOfTriangles : public CRenderizableDisplayList
{
        DEFINE_SERIALIZABLE(CSetOfTriangles)
   public:
        /**
          * Triangle definition. Each vertex has three spatial coordinates and four
         * color values.
          */
        struct TTriangle
        {
                inline TTriangle()
                {
                        for (size_t i = 0; i < 3; i++)
                        {
                                r[i] = g[i] = b[i] = a[i] = 1.0f;
                        }
                }
                inline TTriangle(const mrpt::math::TPolygon3D& p)
                {
                        ASSERT_(p.size() == 3)
                        for (size_t i = 0; i < 3; i++)
                        {
                                x[i] = p[i].x;
                                y[i] = p[i].y;
                                z[i] = p[i].z;
                                r[i] = g[i] = b[i] = a[i] = 1.0f;
                        }
                }
                float x[3], y[3], z[3];
                float r[3], g[3], b[3], a[3];
        };
        /**
          * Const iterator type.
          */
        typedef std::vector<TTriangle>::const_iterator const_iterator;
        /**
          * Const reverse iterator type.
          */
        typedef std::vector<TTriangle>::const_reverse_iterator
                const_reverse_iterator;

   protected:
        /**
          * List of triangles.
          * \sa TTriangle
          */
        std::vector<TTriangle> m_triangles;
        /**
          * Transparency enabling.
          */
        bool m_enableTransparency;
        /**
          * Mutable variable used to check whether polygons need to be recalculated.
          */
        mutable bool polygonsUpToDate;
        /**
          * Polygon cache.
          */
        mutable std::vector<mrpt::math::TPolygonWithPlane> tmpPolygons;

   public:
        /**
          * Polygon cache updating.
          */
        void updatePolygons() const;
        /**
          * Clear this object.
          */
        inline void clearTriangles()
        {
                m_triangles.clear();
                polygonsUpToDate = false;
                CRenderizableDisplayList::notifyChange();
        }
        /**
          * Get triangle count.
          */
        inline size_t getTrianglesCount() const { return m_triangles.size(); }
        /**
          * Gets the triangle in a given position.
          */
        inline void getTriangle(size_t idx, TTriangle& t) const
        {
                ASSERT_(idx < m_triangles.size());
                t = m_triangles[idx];
        }
        /**
          * Inserts a triangle into the set.
          */
        inline void insertTriangle(const TTriangle& t)
        {
                m_triangles.push_back(t);
                polygonsUpToDate = false;
                CRenderizableDisplayList::notifyChange();
        }
        /**
          * Inserts a set of triangles, bounded by iterators, into this set.
          * \sa insertTriangle
          */
        template <class InputIterator>
        inline void insertTriangles(
                const InputIterator& begin, const InputIterator& end)
        {
                m_triangles.insert(m_triangles.end(), begin, end);
                polygonsUpToDate = false;
                CRenderizableDisplayList::notifyChange();
        }
        /**
          * Inserts an existing CSetOfTriangles into this one.
          */
        void insertTriangles(const CSetOfTriangles::Ptr& p);
        /**
          * Reserves memory for certain number of triangles, avoiding multiple
         * memory allocation calls.
          */
        inline void reserve(size_t t)
        {
                m_triangles.reserve(t);
                CRenderizableDisplayList::notifyChange();
        }

        /** Enables or disables transparency. */
        inline void enableTransparency(bool v)
        {
                m_enableTransparency = v;
                CRenderizableDisplayList::notifyChange();
        }

        CRenderizable& setColor_u8(const mrpt::utils::TColor& c) override;
        CRenderizable& setColorR_u8(const uint8_t r) override;
        CRenderizable& setColorG_u8(const uint8_t g) override;
        CRenderizable& setColorB_u8(const uint8_t b) override;
        CRenderizable& setColorA_u8(const uint8_t a) override;

        /** Render
          */
        void render_dl() const override;

        /** Ray tracing
          */
        bool traceRay(const mrpt::poses::CPose3D& o, double& dist) const override;

        /**
          * Gets the polygon cache.
          * \sa insertTriangles
          */
        void getPolygons(std::vector<mrpt::math::TPolygon3D>& polys) const;

        /**
          * Inserts a set of triangles, given in a container of either TTriangle's
         * or TPolygon3D
          * \sa insertTriangle
          */
        template <class CONTAINER>
        inline void insertTriangles(const CONTAINER& c)
        {
                this->insertTriangles(c.begin(), c.end());
                CRenderizableDisplayList::notifyChange();
        }

        /**
          * Gets the beginning iterator to this object.
          */
        inline const_iterator begin() const { return m_triangles.begin(); }
        /**
          * Gets the ending iterator to this object.
          */
        inline const_iterator end() const { return m_triangles.end(); }
        /**
          * Gets the reverse beginning iterator to this object, which points to the
         * last triangle.
          */
        inline const_reverse_iterator rbegin() const
        {
                return m_triangles.rbegin();
        }
        /**
          * Gets the reverse ending iterator to this object, which points to the
         * beginning of the actual set.
          */
        inline const_reverse_iterator rend() const { return m_triangles.rend(); }
        /** Evaluates the bounding box of this object (including possible children)
         * in the coordinate frame of the object parent. */
        void getBoundingBox(
                mrpt::math::TPoint3D& bb_min,
                mrpt::math::TPoint3D& bb_max) const override;

        /** Constructor
          */
        CSetOfTriangles(bool enableTransparency = false)
                : m_triangles(),
                  m_enableTransparency(enableTransparency),
                  polygonsUpToDate(false)
        {
        }

        /** Private, virtual destructor: only can be deleted from smart pointers */
        virtual ~CSetOfTriangles() {}
};
/** Inserts a set of triangles into the list; note that this method allows to
 * pass another CSetOfTriangles as argument. Allows call chaining.
  * \sa mrpt::opengl::CSetOfTriangles::insertTriangle
  */
template <class T>
inline CSetOfTriangles::Ptr& operator<<(CSetOfTriangles::Ptr& s, const T& t)
{
        s->insertTriangles(t.begin(), t.end());
        return s;
}
/** Inserts a triangle into the list. Allows call chaining.
  * \sa mrpt::opengl::CSetOfTriangles::insertTriangle
  */
template <>
inline CSetOfTriangles::Ptr& operator<<(
        CSetOfTriangles::Ptr& s, const CSetOfTriangles::TTriangle& t)
{
        s->insertTriangle(t);
        return s;
}

}  // end namespace

}  // End of namespace

#endif