CRenderizableDisplayList.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_CRenderizableDisplayList_H
#define opengl_CRenderizableDisplayList_H
 
#include <mrpt/opengl/CRenderizable.h>
 
namespace mrpt
{
namespace opengl
{
#define INVALID_DISPLAY_LIST_ID static_cast<unsigned int>(-1)
 
/** A renderizable object suitable for rendering with OpenGL's display lists.
 *   The idea is to use the derived classes' ::render() method to save all the
 *primitives
 *   into one display list, then in subsequent rendering events, just execute
 *the list.
 *   This method is normally faster since it avoids the bottleneck between
 *CPU-GPU. On the
 *   other hand, it demands more memory on the graphic card.
 *
 *  Instructions for implementing derived classes:
 *              - Each time the object is modified is some way that modifies its
 *appearance, you must call notifyChange()
 *              - Implement the rendering method: render_dl(), calling to OpenGL
 *primitives
 *as usual. They'll be saved in a display list transparently.
 *
 *  \sa mrpt::opengl::CRenderizable
 * \ingroup mrpt_opengl_grp
 */
class CRenderizableDisplayList : public mrpt::opengl::CRenderizable
{
        DEFINE_VIRTUAL_SERIALIZABLE(CRenderizableDisplayList)
 
   private:
        /** Display list ID, for derived classes that want to use it (it's
         * automatically deleted and freed on destruction of this base class). */
        mutable unsigned int m_dl;
        /** If using display lists, this is true when the list must be updated (the
         * object changes, it's the first rendering, etc...). */
        mutable bool m_dl_recreate;
 
   protected:
        /** @name Methods accesible or implemented by derived classes
                @{ */
 
        /** Must be called to notify that the object has changed (so, the display
         * list must be updated) */
        EIGEN_STRONG_INLINE void notifyChange() const { m_dl_recreate = true; }
        /** Derived classes must implement this method to the render the object. */
        virtual void render_dl() const = 0;
 
        /** Optional: If the object has some state in which creating a display list
         * is NOT preferred over direct rendering,
         *  implement this method and return "true" in those cases. */
        virtual bool should_skip_display_list_cache() const { return false; }
        inline void readFromStreamRender(mrpt::serialization::CArchive& in)
        {
                CRenderizable::readFromStreamRender(in);
                notifyChange();
        }
 
        /** @} */
 
   public:
        CRenderizableDisplayList();
        virtual ~CRenderizableDisplayList();
 
        /** Render the object, regenerating the display list if needed, otherwise
         * just calling it. */
        void render() const override;
 
        /** @name Changes the appearance of the object to render (methods from
           CRenderizable that need to be redefined)
                @{ */
        /**Color components in the range [0,255] \return a ref to this */
        CRenderizable& setColorR_u8(const uint8_t r) override
        {
                m_color.R = r;
                notifyChange();
                return *this;
        }
        /**Color components in the range [0,255] \return a ref to this */
        CRenderizable& setColorG_u8(const uint8_t g) override
        {
                m_color.G = g;
                notifyChange();
                return *this;
        }
        /**Color components in the range [0,255] \return a ref to this */
        CRenderizable& setColorB_u8(const uint8_t b) override
        {
                m_color.B = b;
                notifyChange();
                return *this;
        }
        /**Color components in the range [0,255] \return a ref to this */
        CRenderizable& setColorA_u8(const uint8_t a) override
        {
                m_color.A = a;
                notifyChange();
                return *this;
        }
        /** Changes the default object color \return a ref to this */
        CRenderizable& setColor_u8(const mrpt::img::TColor& c) override
        {
                CRenderizable::setColor_u8(c);
                notifyChange();
                return *this;
        }
        /**Color components in the range [0,255] \return a ref to this */
        inline CRenderizable& setColor_u8(
                uint8_t R, uint8_t G, uint8_t B, uint8_t A = 255)
        {
                CRenderizable::setColor_u8(R, G, B, A);
                notifyChange();
                return *this;
        }
        /** @} */
};
 
}  // namespace opengl
 
}  // namespace mrpt
 
#endif