#ifndef DRAWABLEMESHIMAGE_H

#define DRAWABLEMESHIMAGE_H

#include <memory>

// TnzExt includes

#include "meshtexturizer.h"

// TnzCore includes

#include "tgldisplaylistsmanager.h"

#undef DVAPI

#undef DVVAR

#ifdef TNZEXT_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//***************************************************************************************

//    DrawableMeshImage definition

//***************************************************************************************

//! DrawableTextureData is a MeshTexturizer::TextureData wrapper that

struct DrawableTextureData {

	MeshTexturizer::TextureData *m_textureData; //!< The wrapped texture data

public:

	DrawableTextureData() {}

	~DrawableTextureData();

private:

	friend class TTexturesStorage;

	int m_texId;	 //!< The texture Id in MeshTexturizer

	int m_dlSpaceId; //!< Object's display lists id

	int m_objIdx;	//!< Object index in the container

private:

	// Not copyable

	DrawableTextureData(const DrawableTextureData &);

	DrawableTextureData &operator=(const DrawableTextureData &);

};

typedef std::shared_ptr<DrawableTextureData> DrawableTextureDataP;

//***************************************************************************************

//    TexturesStorage declaration

//***************************************************************************************

/*!

  \brief    TTexturesStorage is the class responsible for the storage of textures associated with mesh rendering.

  \details  This class deals with textures storage and meshes compilation for drawing purposes.

            An OpenGL texture is typically split into several tiles before being rendered. A texturized mesh is then

            compiled against a texture in order to decide which mesh faces must be rendered with a given texture

            tile.

            The TTextureStorage class uses a QCache to store texture objects up to a maximum memory size, plus all

            the already compiled mesh objects against the stored textures. Whenever a texture loading procedure would

            exceed the maximum textures size, the least accessed stored textures are automatically removed from the

            storage to make space for the newly assigned one.

            Textures can be \a stored only if the OpenGL context they are loaded on has a valid known display lists

            proxy submitted in the TGLDisplayListsManager. In case the OpenGL context does not have a proxy, the

            loaded texture is a temporary, and will be deleted as soon as the returned TexturObject is destroyed

            (so, make sure the associated context is still current at that point).

  \note     TTexturesStorage is thread-safe.

  \sa       The TGLDisplayListsManager class.

*/

class DVAPI TTexturesStorage : private TGLDisplayListsManager::Observer

{

public:

	static TTexturesStorage *instance();

	/*!

    \brief    Stores the specified raster to a group of OpenGL textures, returning a reference

              pointer ensuring the texture survival during its lifetime.

    \warning  This class may keep a copy of the specified texture only for a \b limited

              amount of time, \a if the current context has an associated display lists

              space proxy. Users must always be ready to \a reload the texture in case

              it was not found.

  */

	DrawableTextureDataP loadTexture(const std::string &textureId, const TRaster32P &ras, const TRectD &geometry);

	//! Releases the texture associated with the specified texture id.

	void unloadTexture(const std::string &textureId);

	//! Returns the texture data associated to the specified string identifier.

	DrawableTextureDataP getTextureData(const std::string &textureId);

private:

	TTexturesStorage();

	~TTexturesStorage();

	void onDisplayListDestroyed(int dlSpaceId);

};

#endif // DRAWABLEMESHIMAGE_H