COpenGLStandardObject.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, 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_COpenGLStandardObject_H
#define opengl_COpenGLStandardObject_H

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

namespace mrpt::opengl
{
using _GLENUM = uint32_t;

/**
  * Objects of this class represent a generic openGL object without specific
 * geometric properties.
  * \ingroup mrpt_opengl_grp
  */
class COpenGLStandardObject : public CRenderizableDisplayList
{
    DEFINE_SERIALIZABLE(COpenGLStandardObject)
   protected:
    /**
      * OpenGL identifier of the object type.
      */
    _GLENUM type;
    /**
      * Set of points in which consists this object.
      */
    std::vector<mrpt::math::TPoint3D> vertices;
    /**
      * Granularity of the openGL elements. 3 for GL_TRIANGLES, 4 for GL_QUADS,
     * and so on. Setting it to 0 will generate a single openGL object.
      */
    uint32_t chunkSize;
    /**
      * Set of openGL properties enabled in the rendering of this object.
      */
    std::vector<_GLENUM> enabled;
    float normal[3];

   public:
    /**
      * Render.
      * \sa mrpt::opengl::CRenderizable
      */
    virtual void render_dl() const override;
    /** 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;
    /**
      * Ray Tracing. Will always return false, since objects of this class are
     * not intended to have geometric properties.
      * \sa mrpt::opengl::CRenderizable
      */
    bool traceRay(const mrpt::poses::CPose3D& o, double& dist) const override;
    /**
      * Creation of object from type, vertices, chunk size and a list of enabled
     * openGL flags.
      * \throw std::logic_error if the number of vertices is not an exact
     * multiple of the chunk size.
      */
    static COpenGLStandardObject::Ptr Create(
        _GLENUM t, const std::vector<mrpt::math::TPoint3D>& v, uint32_t cs = 0,
        const std::vector<_GLENUM>& en = std::vector<_GLENUM>());

    /**
      * Enable some openGL flag.
      */
    inline void enable(_GLENUM flag)
    {
        if (find(enabled.begin(), enabled.end(), flag) == enabled.end())
            enabled.push_back(flag);
        CRenderizableDisplayList::notifyChange();
    }
    /**
      * Disable some openGL flag.
      */
    void disable(_GLENUM flag);
    /**
      * Check whether an openGL will be enabled during the rendering of this
     * object.
      */
    inline bool isEnabled(_GLENUM flag) const
    {
        return find(enabled.begin(), enabled.end(), flag) != enabled.end();
    }
    /**
      * Get a list of all currently enabled openGL flags.
      */
    inline void getEnabledFlags(std::vector<_GLENUM>& v) const { v = enabled; }
    /**
      * Set the list of all openGL flags.
      */
    inline void setFlags(const std::vector<_GLENUM>& v)
    {
        enabled = v;
        CRenderizableDisplayList::notifyChange();
    }
    /**
      * Set the normal vector to this object.
      */
    inline void setNormal(const float (&n)[3])
    {
        for (size_t i = 0; i < 3; i++) normal[i] = n[i];
        CRenderizableDisplayList::notifyChange();
    }
    /**
      * Gets the normal vector to this object.
      */
    inline void getNormal(float (&n)[3]) const
    {
        for (size_t i = 0; i < 3; i++) n[i] = normal[i];
    }
    /**
      * Constructor with all the information.
      */
    COpenGLStandardObject(
        _GLENUM t, const std::vector<mrpt::math::TPoint3D>& v, uint32_t cs,
        const std::vector<_GLENUM>& en)
        : type(t), vertices(v), chunkSize(cs), enabled(en)
    {
        for (size_t i = 0; i < 3; i++) normal[i] = 0.0;
    }
    /**
      * Baic empty constructor, initializes to default.
      */
    COpenGLStandardObject()
        : type(0),
          vertices(std::vector<mrpt::math::TPoint3D>(0)),
          chunkSize(0),
          enabled(std::vector<_GLENUM>())
    {
        for (size_t i = 0; i < 3; i++) normal[i] = 0.0;
    }
    /**
      * Destructor.
      */
    virtual ~COpenGLStandardObject() {}
};
}
#endif