CRenderizableDisplayList.cpp

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 |
   +------------------------------------------------------------------------+ */

#include "opengl-precomp.h"  // Precompiled header

#include <mrpt/opengl/CRenderizableDisplayList.h>
#include <mrpt/serialization/CArchive.h>
#include <mutex>
#include <cstdlib>  // atexit()

#include "opengl_internals.h"

using namespace std;
using namespace mrpt;
using namespace mrpt::opengl;

IMPLEMENTS_VIRTUAL_SERIALIZABLE(
    CRenderizableDisplayList, CRenderizable, mrpt::opengl)

// TAuxDLData: needed since it seems we must delete display lists from the same
// thread we create them....

// Phoenix Singleton pattern
void deleteSingleton();
struct TAuxDLData
{
    std::vector<unsigned int> dls_to_delete;
    std::recursive_mutex dls_to_delete_cs;

    static TAuxDLData& getSingleton()
    {
        if (!m_pInstance)
        {
            m_pInstance = new TAuxDLData;
            std::atexit(deleteSingleton);
        }
        return *m_pInstance;
    }

    static TAuxDLData* m_pInstance;
};
void deleteSingleton()
{
    if (TAuxDLData::m_pInstance)
    {
        delete TAuxDLData::m_pInstance;
        TAuxDLData::m_pInstance = nullptr;
    }
}
TAuxDLData* TAuxDLData::m_pInstance = nullptr;

// Default constructor:
CRenderizableDisplayList::CRenderizableDisplayList()
    : m_dl(INVALID_DISPLAY_LIST_ID), m_dl_recreate(true)
{
}

// Destructor:
CRenderizableDisplayList::~CRenderizableDisplayList()
{
    // If we had an associated display list:
    if (m_dl != INVALID_DISPLAY_LIST_ID)
    {
        // Delete the graphical memory (actually, enque the request...)
        TAuxDLData& obj = TAuxDLData::getSingleton();
        obj.dls_to_delete_cs.lock();
        obj.dls_to_delete.push_back(m_dl);
        obj.dls_to_delete_cs.unlock();
    }
}

// This is the virtual rendering method CRenderizable expects from us.
// We call our derived class to save the list, then just call that list:
void CRenderizableDisplayList::render() const
{
#if MRPT_HAS_OPENGL_GLUT
    if (should_skip_display_list_cache())
    {
        // The object is in a state where caching a display list is not
        // preferred, so render directly:
        render_dl();
    }
    else
    {
        // We must delete pending dl's in the same thread we create them, so,
        // let's do it here, for example:
        TAuxDLData& obj = TAuxDLData::getSingleton();
        if (!obj.dls_to_delete.empty())
        {
            obj.dls_to_delete_cs.lock();
#if MRPT_HAS_OPENGL_GLUT
            for (size_t i = 0; i < obj.dls_to_delete.size(); i++)
                glDeleteLists(obj.dls_to_delete[i], 1);
#endif
            obj.dls_to_delete.clear();
            obj.dls_to_delete_cs.unlock();
        }

        if (m_dl == INVALID_DISPLAY_LIST_ID)
        {
            m_dl = glGenLists(1);  // Assign list ID upon first usage.
            if (glGetError() != GL_NO_ERROR)
                std::cerr << "glGenLists: Error" << std::endl;
        }

        if (m_dl_recreate)
        {
            m_dl_recreate = false;
            glNewList(m_dl, GL_COMPILE);
            if (glGetError() != GL_NO_ERROR)
                std::cerr << "glNewList: Error" << std::endl;

            // Call derived class:
            render_dl();

            glEndList();
            if (glGetError() != GL_NO_ERROR)
                std::cerr << "glEndList: Error" << std::endl;
        }

        // Call the list:
        glCallList(m_dl);
        glGetError();  // Clear any error flags that may remain: this is because
        // it seems FBO rendering lead to "errors" but it
        // actually renders OK...
    }
#endif
}