#ifndef MESHTEXTURIZER_H
#define MESHTEXTURIZER_H
// TnzCore includes
#include "traster.h"
#include "tgl.h" // OpenGL includes
// STL includes
#include <vector>
#include <deque>
#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
//******************************************************************************************
// MeshTexturizer declaration
//******************************************************************************************
/*!
\brief The MeshTexturizer class acts as a management wrapper to OpenGL texturing
capabilities, in particular concerning texture virtualization.
\details The first step in OpenGL texturing requires copying a texture into the video ram
(\a VRAM). Now, OpenGL documentation specifies that, although there is no limit
to the \a number of allowed textures, there \a are limits to the \b size of said
textures, which can be tested by asking OpenGL whether it can accomodate specific
texture requests or not.
Technically, the MeshTexturizer class acts as a virtualization manager that can be
used to allow texturization with arbitrary texture sizes. The manager accepts raster
images that are cut up into tiles and bound to VRAM.
Please, observe that the number of texture objects is typically not an issue, as
OpenGL is able to swap texture objects between RAM and VRAM, depending on which
textures have been used most frequently. In other words, since MeshTexturizer ensures
the granularity required by OpenGL, textures can be used until the process runs out of
memory - of course, swapping can be a source of slowdowns, though.
\remark Subdivision into tiles is designed to work for both premultiplied \a and
non-premultiplied textures.
\remark MeshTexturizer instances are thread-safe.
*/
class DVAPI MeshTexturizer
{
public:
struct TextureData;
enum PremultMode //! Premultiplication specifier for texture binding.
{
NONPREMULTIPLIED, //!< Texture is not premultiplied.
PREMULTIPLIED, //!< Texture is premultiplied.
};
public:
MeshTexturizer();
~MeshTexturizer();
/*! \details The bindTexture() function is used to specify a 32-bit fullcolor
raster as a texture to be used for mesh rendering. The supplied
geometry rect defines its position with respect to compiled meshes.
\remark The premultiplication specifier is used to tell the texturizer how
to add a proper transparent border surrounding texture tiles.
This border is essential to draw transparent pixels beyond a texture
tile's content.
\returns The internal id used to reference to the input raster. */
int bindTexture(const TRaster32P &ras, const TRectD &geometry, //!< Moves a \a copy of the supplied raster image to VRAM,
PremultMode premultiplyMode = NONPREMULTIPLIED); //! and assigns an identification number to it. \param ras Texture to be copied to VRAM. \param geometry The texture's geometry in the world - with respect to compiled meshes. \param premultiplyMode Specified whether ras is to be intended premultiplied or not.
/*! \warning The pointer returned by getTextureData() is <B>owned by this class</B> -
it must not be deleted. */
TextureData *getTextureData(int textureId); //!< Retrieves the texture data built from a previously
//! bound texture image. \param textureId Identifier of the texture to be retrieved \returns See summary.
/*! \details The texture identifier specified to rebindTexture() is retained,
and the effect is that of an unbindTexture() - bindTexture() combo.
\note Pre-compiled mesh data against the old texture can be retained \b if
the newly supplied texture size and geometry are the \b same as the old one. */
void rebindTexture(int textureId,
const TRaster32P &ras, const TRectD &geometry, //!< Rebinds the image bound to the specified texture
PremultMode premultiplyMode = NONPREMULTIPLIED); //! id to a new image.
void unbindTexture(int textureId); //!< Deletes the texture associated to the passed id. \param textureId Identifier of the texture to be unbound.
private:
class Imp;
Imp *m_imp;
private:
// Not copyable
MeshTexturizer(const MeshTexturizer &);
MeshTexturizer &operator=(const MeshTexturizer &);
};
//******************************************************************************************
// MeshTexturizer:::CompiledData definition
//******************************************************************************************
/*!
\brief The MeshTexturizer-owned data about a texture.
\details The purpose of MeshTexturizer is that of storing in VRAM a set of textures
cut up into tiles. This struture holds the data about the end-product of
texture loading into a MeshTexturizer instance.
*/
struct MeshTexturizer::TextureData {
struct TileData //! Data structure for a texture tile.
{
GLuint m_textureId; //!< OpenGL texture identifier.
TRectD m_tileGeometry; //!< The tile's world geometry.
};
public:
TRectD m_geom; //!< The original texture's world geometry.
std::vector<TileData> m_tileDatas; //!< The texture tiles the original texture was split into.
public:
TextureData() {}
TextureData(const TRectD &geom) : m_geom(geom) {}
~TextureData()
{
int t, tilesCount = m_tileDatas.size();
for (t = 0; t < tilesCount; ++t)
glDeleteTextures(1, &m_tileDatas[t].m_textureId);
}
private:
// Not copyable
TextureData(const TextureData &);
TextureData &operator=(const TextureData &);
};
#endif // MESHTEXTURIZER_H