sources/tnzext/ttexturesstorage.cpp

#include <memory>

// TnzCore includes
#include "tgl.h"

// TnzExt includes
#include "ext/meshtexturizer.h"

// tcg includes
#include "tcg/tcg_list.h"

// Qt includes
#include <QString>
#include <QCache>
#include <QMutex>
#include <QMutexLocker>

#include "ext/ttexturesstorage.h"

//***************************************************************************************
//    Local namespace - structures
//***************************************************************************************

struct TexturesContainer {
  MeshTexturizer
      m_texturizer;  //!< The mesh texturizer - actual textures container
  tcg::list<QString> m_keys;  //!< Keys in the storage

public:
  TexturesContainer() {}

private:
  TexturesContainer(const TexturesContainer &);
  TexturesContainer &operator=(const TexturesContainer &);
};

//***************************************************************************************
//    Local namespace - variables
//***************************************************************************************

namespace {

QMutex l_mutex(QMutex::Recursive);  // A mutex is needed to synchronize access
                                    // to the following objects

std::map<int, TexturesContainer *>
    l_texturesContainers;  // Texture Containers by display lists space id
QCache<QString, DrawableTextureDataP> l_objects(500 * 1024);  // 500 MB cache
                                                              // for now - NOTE:
                                                              // MUST be
                                                              // allocated
                                                              // before the
                                                              // following

}  // namespace

//***************************************************************************************
//    Local namespace - global functions
//***************************************************************************************

namespace {

inline QString textureString(int dlSpaceId, const std::string &texId) {
  return QString::number(dlSpaceId) + "_" + QString::fromStdString(texId);
}

//-------------------------------------------------------------------------------------

inline void deleteTexturesContainer(
    const std::pair<int, TexturesContainer *> &pair) {
  delete pair.second;
}
}

//***************************************************************************************
//    DrawableTextureData implementation
//***************************************************************************************

DrawableTextureData::~DrawableTextureData() {
  QMutexLocker locker(&l_mutex);

  TexturesContainer *texContainer = l_texturesContainers[m_dlSpaceId];

  if (m_dlSpaceId >= 0) {
    // Load the container's display lists space (remember current OpenGL
    // context, too)
    TGLDisplayListsProxy *proxy =
        TGLDisplayListsManager::instance()->dlProxy(m_dlSpaceId);

    TGlContext currentContext = tglGetCurrentContext();

    // Unbind the textures
    {
      QMutexLocker locker(proxy->mutex());

      proxy->makeCurrent();
      texContainer->m_texturizer.unbindTexture(m_texId);
    }

    // Restore OpenGL context - equivalent to tglDoneCurrent if currentContext
    // == TGlContext()
    tglMakeCurrent(currentContext);
  } else
    // Temporary - use current OpenGL context directly
    texContainer->m_texturizer.unbindTexture(m_texId);

  texContainer->m_keys.erase(m_objIdx);
}

//***************************************************************************************
//    TTexturesStorage implementation
//***************************************************************************************

TTexturesStorage::TTexturesStorage() {
  // This singleton is dependent on TGLDisplayListsManager
  TGLDisplayListsManager::instance()->addObserver(this);
}

//-------------------------------------------------------------------------------------

TTexturesStorage::~TTexturesStorage() {
  l_objects.clear();
  std::for_each(l_texturesContainers.begin(), l_texturesContainers.end(),
                deleteTexturesContainer);
}

//-------------------------------------------------------------------------------------

TTexturesStorage *TTexturesStorage::instance() {
  static TTexturesStorage theInstance;
  return &theInstance;
}

//-------------------------------------------------------------------------------------

DrawableTextureDataP TTexturesStorage::loadTexture(const std::string &textureId,
                                                   const TRaster32P &ras,
                                                   const TRectD &geometry) {
  // Try to retrieve the proxy associated to current OpenGL context
  TGlContext currentContext = tglGetCurrentContext();
  int dlSpaceId =
      TGLDisplayListsManager::instance()->displayListsSpaceId(currentContext);

  QString texString(::textureString(dlSpaceId, textureId));

  // Deal with containers
  QMutexLocker locker(&l_mutex);

  // If necessary, allocate a textures container
  std::map<int, TexturesContainer *>::iterator it =
      l_texturesContainers.find(dlSpaceId);
  if (it == l_texturesContainers.end())
    it = l_texturesContainers
             .insert(std::make_pair(dlSpaceId, new TexturesContainer))
             .first;

  MeshTexturizer &texturizer = it->second->m_texturizer;

  DrawableTextureDataP dataPtr = std::make_shared<DrawableTextureData>();
  DrawableTextureData *data    = dataPtr.get();

  data->m_dlSpaceId   = dlSpaceId;
  data->m_texId       = texturizer.bindTexture(ras, geometry);
  data->m_objIdx      = it->second->m_keys.push_back(texString);
  data->m_textureData = texturizer.getTextureData(data->m_texId);

  l_objects.insert(texString, new DrawableTextureDataP(dataPtr),
                   (ras->getLx() * ras->getLy() * ras->getPixelSize()) >> 10);

  if (dlSpaceId < 0) {
    // obj is a temporary. It was pushed in the cache to make space for it -
    // however, it must not be
    // stored. Remove it now.
    l_objects.remove(texString);
  }

  return dataPtr;
}

//-------------------------------------------------------------------------------------

void TTexturesStorage::unloadTexture(const std::string &textureId) {
  QMutexLocker locker(&l_mutex);

  // Remove the specified texture from ALL the display lists spaces
  std::map<int, TexturesContainer *>::iterator it,
      iEnd(l_texturesContainers.end());
  for (it = l_texturesContainers.begin(); it != iEnd; ++it)
    l_objects.remove(::textureString(it->first, textureId));
}

//-----------------------------------------------------------------------------------

void TTexturesStorage::onDisplayListDestroyed(int dlSpaceId) {
  QMutexLocker locker(&l_mutex);

  // Remove the textures container associated with dlSpaceId
  std::map<int, TexturesContainer *>::iterator it =
      l_texturesContainers.find(dlSpaceId);
  if (it == l_texturesContainers.end()) return;

  tcg::list<QString>::iterator st, sEnd(it->second->m_keys.end());

  for (st = it->second->m_keys.begin(); st != sEnd;)  // Note that the increment
                                                      // is performed BEFORE the
                                                      // texture is removed.
    l_objects.remove(*st++);  // This is because texture removal may destroy the
                              // key being addressed,
                              // whose iterator would then be invalidated.
  delete it->second;
  l_texturesContainers.erase(it);
}

//-------------------------------------------------------------------------------------

DrawableTextureDataP TTexturesStorage::getTextureData(
    const std::string &textureId) {
  // Get current display lists space
  TGlContext currentContext = tglGetCurrentContext();
  int dlSpaceId =
      TGLDisplayListsManager::instance()->displayListsSpaceId(currentContext);

  // If there is no known associated display lists space, the texture cannot be
  // stored.
  if (dlSpaceId < 0) return DrawableTextureDataP();

  QMutexLocker locker(&l_mutex);

  // Search the texture object
  QString texString(::textureString(dlSpaceId, textureId));
  if (!l_objects.contains(texString)) return DrawableTextureDataP();

  return *l_objects.object(texString);
}