#ifndef TEXTIMAGE_H
#define TEXTIMAGE_H

/**
    Cette classe permet d'incruster des textes dans
    des IImage, ITexture ou directement à l'écran.
    Elle peut aussi tout simplement renvoyer une image
    contenant un texte.

    Elle supporte les fichiers *.ttf, il est donc possible
    d'afficher tout ce que vous voulez. Utile pour des
    informations de jeu à afficher directement à
    l'écran (HUD par exemple).

    Cette classe utilise un encodage UNICODE lors des
    appels au fichiers de police (*.ttf).
    Pour une compatibilité assurée, configurez votre
    IDE pour qu'il enregistre vos fichiers en UTF-8.
    La classe dispose d'un convertisseur UTF-8 vers
    UNICODE.

    Le texte doit donc être au format UTF-8 ou UNICODE.
    Ces formats étant les plus complets, tous les
    caractères sont affichables. Caractères spéciaux,
    Kanas et Kanjis, Idéogrammes chinois et coréens...
    Du moment que la police que vous utilisez les
    contiennent bien sûr.

    /!\\ Attention : TOUT texte déclaré comme étant UTF-8 sera
    converti en UNICODE pour l'affichage. Néanmoins,
    le texte enregistré au sein de la classe restera
    dans le même encodage. Il est donc important de
    bien précisé l'encodage dans lequel vous transmettez
    le texte. /!\\
**/

/** Irrlicht **/
#include <irrMath.h>
#include <irrTypes.h>
#include <IVideoDriver.h>
using namespace irr;
using namespace core;
using namespace video;

/** Freetype2 **/
#include <ft2build.h>
#include FT_FREETYPE_H


class TextImage
{
    public:
        //! constructeur
        //! ATTENTION : Il faut absolument donner un pointeur sur le video
        //! driver avant toute création d'images. Cela peut être fait avec
        //! setVideoDriver().
        TextImage(IVideoDriver *driver=NULL);
        TextImage(stringw text, stringc pathfont="", u32 fontsize=12, SColor textcolor=SColor(0), bool isUTF8text=true);
        //! destructeur
        ~TextImage();

        /** Accesseurs **/
        //! modifie le texte
        void setText(stringw text, bool isUTF8text=true);
        //! renvoie le texte
        stringw getText();
        //! renvoie true si le texte à été renseigné comme étant au format UTF-8
        bool isUTF8Text();
        //! demande la création d'une nouvelle font
        void setFont(stringc pathfont, u32 fontsize);
        //! renvoie la taille de la police actuelle (0 si pas de font)
        u32 getFontSize();
        //! demande la création d'une nouvelle font et change la couleur
        void setFontAndColor(stringc pathfont, u32 fontsize, SColor textcolor);
        //! modifie la couleur du texte
        void setTextColor(SColor textcolor);
        //! renvoie la couleur du texte
        SColor getTextColor();
        //! modifie tout les paramètres
        void setAll(stringw text, stringc pathfont, u32 fontsize, SColor textcolor=SColor(0), bool isUTF8text=true);
        //! renvoie l'image originale
        IImage* getImage();
        //! renvoie une copie de l'image
        IImage* getCopyImage();
        //! donne un pointeur sur le videodriver à la classe
        static void setVideoDriver(IVideoDriver *driver);

        /** création graphique **/
        //! (1 LIGNE) créé l'image contenant le texte (une copie est accessible avec getImage et getCopyImage)
        void createImageFromTextLine();
        //! Détruit l'image contenant le texte
        void destroyTextImage();
        /** IImage **/
        //! (1 LIGNE) incruste le texte dans une image
        //! Si l'image du texte n'a pas été créé avant, elle le fait.
        void blendTextLineOnImage(IImage *image, position2di position=position2di(0));
        //! (1 LIGNE) créé une copie de l'image puis incruste le texte dans l'image copiée (permet de garder l'image originale intacte)
        //! Si l'image du texte n'a pas été créé avant, elle le fait.
        IImage* blendTextLineOnCopiedImage(IImage *original, position2di position=position2di(0));
        //! (INDEPENDANT DU NOMBRE DE LIGNES) copie le texte sur une image
        //! Si l'image du texte n'a pas été créé avant, elle le fait.
        void blendTextOnImage(IImage *destination, position2di position=position2di(0));

        /** Ecran **/
        //! (1 LIGNE) incruste le texte dans l'écran
        //! Si l'image du texte n'a pas été créé avant, elle le fait.
        void blendTextLineOnScreen(position2di position=position2di(0));


        /** conversion **/
        //! convertit un stringw UTF-8 en stringw au format unicode
        static stringw stringUTF8toUNICODE(stringw texte);


    protected:
        /** membres **/
        stringw mText;
        bool mUTF8Text;
        IImage *mImage;
        FT_Face mFont;
        SColor mTextColor;

        /** fonctions protégées **/
        //! dessine un caractère (le caractère doit être au format UNICODE)
        //! et renvoie la position du prochain caractère
        //! ATTENTION : la position sur Y est modifié lors d'un saut de ligne '\
'
        position2di drawChar(IImage *dest, wchar_t caractere, position2di position);
        //! renvoie la largeur d'un caractère (le caractère doit être au format UNICODE)
        //! renvoie -1 si il rencontre un saut de ligne
        s32 getCharWidth(wchar_t caractere);
        //! renvoie la largeur d'une chaîne de caractères (la chaîne doit être au format UNICODE)
        //! si stop_if_return est mis à true, il arrête le comptage s'il rencontre un retour chariot
        u32 getStringWidth(stringw string, bool stop_if_return=false);


    private:
        //! membres statiques
        static FT_Library mLibrary;
        static IVideoDriver *mDriver;
        //! compteur d'instances
        static u32 mNbInstances;
};

#endif // TEXTIMAGE_H

#include "TextImage.h"

//! Initialisation des membres statiques
FT_Library TextImage::mLibrary = NULL;
u32 TextImage::mNbInstances = 0;
IVideoDriver* TextImage::mDriver=NULL;

//! constructeur
//! ATTENTION : Il faut absolument donner un pointeur sur le video
//! driver avant toute création d'images. Cela peut être fait avec
//! setVideoDriver().
TextImage::TextImage(IVideoDriver *driver)
: mText(""), mUTF8Text(true), mImage(NULL), mFont(NULL), mTextColor(SColor(0))
{
    // on copie le pointeur sur IVideoDriver
    if(driver) mDriver = driver;
}
TextImage::TextImage(stringw text, stringc pathfont, u32 fontsize, SColor textcolor, bool isUTF8text)
: mText(text), mUTF8Text(isUTF8text), mImage(NULL), mFont(NULL), mTextColor(textcolor)
{
    // Si c'est la première instance, on initialise la librairie.
    if(!mNbInstances) FT_Init_FreeType(&mLibrary);
    // Une instance est créé donc on incrémente le compteur.
    mNbInstances++;
    // Si un texte est valide
    if(text.size())
    {
        // on enregistre le texte
        mText = text;
        // Si un pathfont est présent
        if(pathfont.size())
        {
            // chargement de la font
            FT_New_Face( mLibrary, pathfont.c_str(), 0, &mFont );
            // taille de police
            if(mFont) FT_Set_Char_Size(mFont, fontsize*64, 0, 96, 0);
        }
    }
}
//! destructeur
TextImage::~TextImage()
{
    // détruit les ressources
    if(mImage) mImage->drop();
    // On détruit une instance donc on décrémente le compteur.
    mNbInstances--;
    // S'il n'y a plus d'instance en cours
    if(!mNbInstances)
    {
        // on libère la librairie.
        FT_Done_FreeType(mLibrary);
        // on libère la font si elle existe
        if(mFont) FT_Done_Face(mFont);
    }
}


/** Accesseurs **/
//! modifie le texte
void TextImage::setText(stringw text, bool isUTF8text)
{
    mText = text;
    mUTF8Text = isUTF8Text();
}
//! renvoie le texte
stringw TextImage::getText()
{
    return mText;
}
//! renvoie true si le texte à été renseigné comme étant au format UTF-8
bool TextImage::isUTF8Text()
{
    return mUTF8Text;
}
//! demande la création d'une nouvelle font
void TextImage::setFont(stringc pathfont, u32 fontsize)
{
    // création de la nouvelle font
    FT_Face newfont = NULL;
    FT_New_Face( mLibrary, pathfont.c_str(), 0, &newfont);
    // si la creation à réussie
    if(newfont)
    {
        // on détruit l'ancienne font
        FT_Done_Face(mFont);
        // on applique la nouvelle
        mFont = newfont;
    }

}
//! demande la création d'une nouvelle font et change la couleur
void TextImage::setFontAndColor(stringc pathfont, u32 fontsize, SColor textcolor)
{
    mTextColor = textcolor;
    setFont(pathfont, fontsize);
}
//! renvoie la taille de la police actuelle (0 si pas de font)
u32 TextImage::getFontSize()
{
    if(mFont) return (mFont->size->metrics.height/96);
    else return 0;
}
//! modifie la couleur du texte
void TextImage::setTextColor(SColor textcolor)
{
    mTextColor = textcolor;
}
//! renvoie la couleur du texte
SColor TextImage::getTextColor()
{
    return mTextColor;
}
//! modifie tout les paramètres
void TextImage::setAll(stringw text, stringc pathfont, u32 fontsize, SColor textcolor, bool isUTF8text)
{
    mText = text;
    setFont(pathfont, fontsize);
    mTextColor = textcolor;
    mUTF8Text = isUTF8Text();
}
//! renvoie l'image originale
IImage* TextImage::getImage()
{
    return mImage;
}
//! renvoie une copie de l'image
IImage* TextImage::getCopyImage()
{
    IImage *copy = NULL;
    if(mDriver)
    {
        // création de l'image "copie"
        copy = mDriver->createImage(mImage->getColorFormat(), mImage->getDimension());
        // copie l'originale dans la "copie"
        mImage->copyTo(copy);
    }
    // renvoie un pointeur sur la copie
    return copy;
}
//! donne un pointeur sur le videodriver à la classe
void TextImage::setVideoDriver(IVideoDriver *driver)
{
    mDriver = driver;
}

/** création graphique **/
//! (1 LIGNE) créé l'image contenant le texte
void TextImage::createImageFromTextLine()
{
    if(mDriver && mFont && mText.size())
    {
        u32 hauteurimage = 1.5*getFontSize();
        // créé une image temporaire d'une longueur de 6000px x taille de police
        IImage *tmp = mDriver->createImage(ECF_A8R8G8B8, dimension2du(6000, hauteurimage));
        if(tmp)
        {
            /// vide l'image
            ///tmp->fill(SColor(0));
            stringw text="";
            // conversion du texte si besoin
            if(mUTF8Text) text = stringUTF8toUNICODE(mText);
            else text = mText;
            // boucle de dessin des caractères
            position2di position(0,0);
            for(u32 a=0; a < text.size(); ++a) position.X = drawChar(tmp, text[a], position).X;
            // recréé l'image finale
            if(mImage) mImage->drop();
            mImage = mDriver->createImage(ECF_A8R8G8B8, dimension2du(position.X, hauteurimage));
            // Copie la zone de texte dans l'image finale
            tmp->copyTo( mImage, position2di(0,0), recti(position2di(0,0), mImage->getDimension()) );
            // libère l'image temporaire
            tmp->drop();
        }
    }
}
//! Détruit l'image contenant le texte
void TextImage::destroyTextImage()
{
    // si l'image existe
    if(mImage)
    {
        // détruit l'image
        mImage->drop();
        // empêche un segfault
        mImage = NULL;
    }
}
/** IImage **/
//! (1 LIGNE) incruste le texte dans une image
//! Si l'image du texte n'a pas été créé avant, elle le fait.
void TextImage::blendTextLineOnImage(IImage *image, position2di position)
{
    // si l'image du texte n'a pas encore été, on le fait
    if(!mImage) createImageFromTextLine();
    if(mImage && image)
    {
        // rectangle de l'image destinataire
        recti zonedest(position2di(0,0), mDriver->getScreenSize());
        // variables
        SColor color, color1, color2;
        s32 X, Y;
        f32 coef1, coef2;
        for(u32 y=0; y < mImage->getDimension().Height; y++)
            for(u32 x=0; x < mImage->getDimension().Width; x++)
            {
                // calcul la position du pixel à l'écran
                X = position.X + x;
                Y = position.Y + y;
                // récupère la couleur de l'image texte
                color1 = mImage->getPixel(x,y);
                // récupère la couleur de l'image destinataire
                color2 = image->getPixel(X,Y);
                // calcul des coef
                coef1 = f32(color1.getAlpha())/255.f;
                coef2 = 1.f-coef1;
                // calcul de la couleur finale
                color = SColor(color2.getAlpha(), color1.getRed()*coef1+color2.getRed()*coef2, color1.getGreen()*coef1+color2.getGreen()*coef2, color1.getBlue()*coef1+color2.getBlue()*coef2);
                // si le pixel est dans l'écran
                if( zonedest.isPointInside(position2di(X, Y)) ) image->setPixel(X,Y,color);
            }
    }
}
//! (1 LIGNE) créé une copie de l'image puis incruste le texte dans l'image copiée (permet de garder l'image originale intacte)
//! Si l'image du texte n'a pas été créé avant, elle le fait.
IImage* TextImage::blendTextLineOnCopiedImage(IImage *original, position2di position)
{
    // si l'image du texte n'a pas encore été, on le fait
    if(!mImage) createImageFromTextLine();
    if(mImage && mDriver)
    {
        IImage *copy = NULL;
        // création de l'image "copie"
        copy = mDriver->createImage(original->getColorFormat(), original->getDimension());
        // copie l'image originale dans la "copie"
        original->copyTo(copy);
        // blit le texte dans la copie
        blendTextLineOnImage(copy, position);
        // retourne un pointeur sur la "copie"
        return copy;
    }
    // le texte n'a pas pu être créé
    return NULL;
}
/** Ecran **/
//! (1 LIGNE) incruste le texte dans l'écran
//! Si l'image du texte n'a pas été créé avant, elle le fait.
void TextImage::blendTextLineOnScreen(position2di position)
{
    // si l'image du texte n'a pas encore été, on le fait
    if(!mImage) createImageFromTextLine();
    if(mImage)
    {
        // rectangle de l'écran
        recti zoneecran(position2di(0,0), mDriver->getScreenSize());
        // variables
        SColor color;
        s32 X, Y;
        for(u32 y=0; y < mImage->getDimension().Height; y++)
            for(u32 x=0; x < mImage->getDimension().Width; x++)
            {
                // récupère la couleur
                color = mImage->getPixel(x,y);
                // calcul la position du pixel à l'écran
                X = position.X + x;
                Y = position.Y + y;
                // si le pixel est dans l'écran
                if(zoneecran.isPointInside(position2di(X, Y))) mDriver->drawPixel(X,Y,color);
            }
    }
}


//! convertit un stringw UTF-8 en stringw au format unicode
stringw TextImage::stringUTF8toUNICODE(stringw texte)
{
    stringw texteUNICODE;
    // pour chaque caractère
    u32 cpt = 0;
    while(cpt < texte.size())
    {
        // variables
        wchar_t charUNICODE = 0;
        u32 nb_octet = 1;
        u8 mask = 0;
        // récupère l'octet n°1
        bool octetbin[8] = {0,0,0,0,0,0,0,0};
        for(u32 bit=0; bit < 8; bit++)
        {
            u8 tmp = texte[cpt] >> bit;
            octetbin[bit] = tmp&0x01;
        }
        // déduit le nombre d'octet pour le caractère en cours
        if(octetbin[7] && octetbin[6])
        {
            if(octetbin[5])
            {
                if(octetbin[4]) nb_octet = 4;
                else nb_octet = 3;
            }
            else nb_octet = 2;
        }
        // traitement du caractère suivant le nombre d'octet
        u8 mot1tmp[4]={0,0,0,0}; u32 *mot1=NULL;
        u8 mot2tmp[4]={0,0,0,0}; u32 *mot2=NULL;
        u8 mot3tmp[4]={0,0,0,0}; u32 *mot3=NULL;
        u8 mot4tmp[4]={0,0,0,0}; u32 *mot4=NULL;
        switch(nb_octet)
        {
            default :
            case 1:
                // on déduit le caractère UNICODE
                charUNICODE = texte[cpt];
            break;
            case 2:
                // on mets l'octet 1 à la 2ème place avec le masque et un décalage de 2
                mot1tmp[1] = texte[cpt]&0x3F;
                mot1 = (u32*)mot1tmp;
                *mot1 >>= 2;
                // on passe à l'octet 2
                cpt++;
                // on mets l'octet 2 à la 1ère place avec le masque
                mot2tmp[0] = texte[cpt]&0x3F;
                mot2 = (u32*)mot2tmp;
                // on combine les mots pour obtenir le caractère UNICODE
                charUNICODE = *mot1|*mot2;
            break;
            case 3:
                // on mets l'octet 1 à la 3ème place avec le masque et un décalage de 2
                mot1tmp[2] = texte[cpt]&0x1F;
                mot1 = (u32*)mot1tmp;
                *mot1 >>= 4;
                // on passe à l'octet 2
                cpt++;
                // on mets l'octet 2 à la 2ème place avec le masque
                mot2tmp[1] = texte[cpt]&0x3F;
                mot2 = (u32*)mot2tmp;
                *mot2 >>= 2;
                // on passe à l'octet 3
                cpt++;
                // on mets l'octet 2 à la 2ème place avec le masque
                mot3tmp[0] = texte[cpt]&0x3F;
                mot3 = (u32*)mot3tmp;
                // on combine les mots pour obtenir le caractère UNICODE
                charUNICODE = *mot1|*mot2|*mot3;
            break;
            case 4:
                // on mets l'octet 1 à la 4ème place avec le masque et un décalage de 2
                mot1tmp[3] = texte[cpt]&0x0F;
                mot1 = (u32*)mot1tmp;
                *mot1 >>= 6;
                // on passe à l'octet 2
                cpt++;
                // on mets l'octet 2 à la 3ème place avec le masque
                mot2tmp[2] = texte[cpt]&0x3F;
                mot2 = (u32*)mot2tmp;
                *mot2 >>= 4;
                // on passe à l'octet 3
                cpt++;
                // on mets l'octet 3 à la 2ème place avec le masque
                mot3tmp[1] = texte[cpt]&0x3F;
                mot3 = (u32*)mot3tmp;
                *mot3 >>= 2;
                // on passe à l'octet 4
                cpt++;
                // on mets l'octet 4 à la 1ère place avec le masque
                mot4tmp[0] = texte[cpt]&0x3F;
                mot4 = (u32*)mot4tmp;
                // on combine les mots pour obtenir le caractère UNICODE
                charUNICODE = *mot1|*mot2|*mot3|*mot4;
            break;
        }
        // insertion du caractère dans la liste
        texteUNICODE += charUNICODE;
        // on présente le caractère suivant
        cpt++;
    }
    return texteUNICODE;
}



/** fonctions protégées **/
//! dessine un caractère (le caractère doit être au format UNICODE)
//! et renvoie la position du prochain caractère
//! ATTENTION : la position sur Y est modifié lors d'un saut de ligne '\
'
position2di TextImage::drawChar(IImage *dest, wchar_t caractere, position2di position)
{
    // si c'est un espace
    if(caractere == ' ') return position + position2di(0.3*getFontSize(), 0);
    // si c'est un caractère "fonction"
    if(caractere == '\
') return position + position2di(0, 1.4*getFontSize());
    if(caractere == '\	') return position + position2di(2*getFontSize(), 0);
    // rendu du bitmap
    FT_Load_Glyph( mFont, FT_Get_Char_Index(mFont, caractere), FT_LOAD_DEFAULT );
    FT_Render_Glyph( mFont->glyph, FT_RENDER_MODE_NORMAL );
    // raccourci vers le bitmap
    FT_Bitmap* bitmap = &mFont->glyph->bitmap;
    // taille du bitmap contenant le char
    s32 x_max=bitmap->width, y_max=bitmap->rows;
    // déclaration de variables
    s32 Xpx, Ypx;
    SColor color = getTextColor();
    // rectangle de l'image
    recti zoneimage(position2di(0,0), dest->getDimension());
    // dessine le caractère
    for(s32 j=0; j < y_max; j++)
        for(s32 i=0; i < x_max; i++)
        {
            // position du pixel
            Xpx=position.X+i;
            Ypx=position.Y+j+getFontSize()-mFont->glyph->bitmap_top;
            // si le pixel est dans l'image
            if( zoneimage.isPointInside(position2di(Xpx, Ypx)) )
            {
                // alpha du pixel
                color.setAlpha( bitmap->buffer[j * bitmap->width + i] );
                // dessine le pixel
                dest->setPixel(Xpx, Ypx, color);
            }
        }
    // retourne la position du prochain caractère
    return position + position2di(x_max+mFont->glyph->bitmap_left, 0);
}
//! renvoie la largeur d'un caractère (le caractère doit être au format UNICODE)
//! renvoie -1 si il rencontre un saut de ligne
s32 TextImage::getCharWidth(wchar_t caractere)
{
    // si c'est un caractère de mise en forme
    if(caractere == ' ') return s32(0.3*getFontSize());
    if(caractere == '\
') return -1;
    if(caractere == '\	') return s32(2*getFontSize());
    // rendu du bitmap
    FT_Load_Glyph( mFont, FT_Get_Char_Index(mFont, caractere), FT_LOAD_DEFAULT );
    FT_Render_Glyph( mFont->glyph, FT_RENDER_MODE_NORMAL );
    // renvoie la taille du caractère
    return s32(mFont->glyph->bitmap.width + mFont->glyph->bitmap_left);
}
//! renvoie la largeur d'une chaîne de caractères (la chaîne doit être au format UNICODE)
u32 TextImage::getStringWidth(stringw string, bool stop_if_return)
{
    u32 width = 0;
    // on cumule la taille de chaque caractère
    for(u32 a=0; a < string.size(); ++a)
    {
        // récupère la taille du caractère
        s32 taille = getCharWidth(string[a]);
        // si c'est un caractère autre que retour chariot
        if(taille > -1) width += taille;
        // si c'est un retour chariot et que l'on doit s'arrêter de compter
        else if(stop_if_return) break;
    }
    // retourne la largeur de la chaîne
    return width;
}

#include <irrlicht.h>
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


#include <TextImage.h>

/**
    /!\\ ATTENTION
    Certains commentaires supposent que l'IDE est configuré
    pour enregistrer les fichiers en UTF-8.
    (Sous CodeBlock : Settings->Editor...->General Settings : rubrique "encoding")./!\\
**/


//! fonction qui dessine une image sur l'écran
void drawImageOnScreen(IImage *image, position2di position, IVideoDriver *driver)
{
    // rectangle de l'écran
    recti zoneecran(position2di(0,0), driver->getScreenSize());
    // variables
    SColor color;
    s32 X, Y;
    for(u32 y=0; y < image->getDimension().Height; y++)
        for(u32 x=0; x < image->getDimension().Width; x++)
        {
            // récupère la couleur
            color = image->getPixel(x,y);
            // calcul la position du pixel à l'écran
            X = position.X + x;
            Y = position.Y + y;
            // si le pixel est dans l'écran
            if(zoneecran.isPointInside(position2di(X, Y))) driver->drawPixel(X,Y,color);
        }
}

static u32 testactif = 0;

class MyEventReceiver : public IEventReceiver
{
    public :

    bool OnEvent(const SEvent& event)
    {
        if(event.EventType == EET_KEY_INPUT_EVENT)
        {
            if(event.KeyInput.PressedDown)
            {
                switch(event.KeyInput.Key)
                {
                    case KEY_KEY_0: testactif = 0; return true;
                    case KEY_KEY_1: testactif = 1; return true;
                    default : break;
                }
            }
        }
        // aucun événement traité
        return false;
    }
};

int main(int argc, char** argv)
{
    // création de la fenêtre
    IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2du(1000, 600), 32, false, false, false, 0);

    // mets en place l'event receiver
    MyEventReceiver receiver;
    device->setEventReceiver(&receiver);

    // récupère des pointeurs utiles
    IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();

    /** Conversion d'une string de UTF-8 vers UNICODE **/
    // créé titre à la fenêtre
    stringw titre = "Des chaînes avec des caractères spéciaux dans la barre de titre.";
    // Le fichier étant encodé en UTF-8, sans cette ligne les caractères spéciaux
    // ne pourrait pas être affichés dans la barre de titre.
    titre = TextImage::stringUTF8toUNICODE(titre);
    // applique le titre à la fenêtre
    device->setWindowCaption(titre.c_str());
    /** ********************************************* **/

    /** Passe l'adresse du videodriver à la classe TextImage **/
    // il est vital car sans lui aucune manipulation sur les images n'est possible.
    TextImage::setVideoDriver(driver);
    /** **************************************************** **/

    /** TEST 0 : Création d'une image texte destinée à être affichée à l'écran **/
    // création d'un objet TextImage
    TextImage imageonscreen("Test imageonscreen : Des caractères spéciaux et japonais. &#26085;&#26412;&#35486;&#12399;&#12416;&#12378;&#12363;&#12375;&#12356;&#12290;", "../medias/umeplus-gothic.ttf", 20);
    imageonscreen.setTextColor(SColor(255,200,200,0));
    // création d'une image contenant le texte
    imageonscreen.createImageFromTextLine();
    /** ******************************************************* **/

    /** TEST 1 : Créé une image sur laquelle on incrustera un
        texte et que l'on affichera à l'écran        **/
    // création de l'image
    IImage *testblit = driver->createImageFromFile("../medias/comparaison 2048px vs 4096px shadowmap.png");
    // création des texte
    TextImage testblittext1("testblit : shadow Map 2048 x 2048 px", "../medias/arial.ttf", 16);
    testblittext1.setTextColor(SColor(255,255,0,0));
    TextImage testblittext2("testblit : shadow Map 4096 x 4096 px", "../medias/arial.ttf", 16);
    testblittext2.setTextColor(SColor(255,0,255,0));
    // blit les textes sur l'image
    // A noter que l'on aurait du appeler "createImageFromTextLine()". Mais si aucune image texte
    // n'est valide (mImage==NULL), "createImageFromTextLine()" est appelé en interne.
    testblittext1.blendTextLineOnImage(testblit, position2di(30,16));
    testblittext2.blendTextLineOnImage(testblit, position2di(530,16));
    /** ******************************************** **/

    // boucle de rendu
    while(device->run())
    {
        // prépare l'écran pour une nouvelle frame
        driver->beginScene(true, true, SColor(0));
        // dessine les éléments 3D de la scène
        smgr->drawAll();

        switch(testactif)
        {
            default : break;
            case 0 :
                /** TEST 0 : dessine du texte directement sur l'écran **/
                imageonscreen.blendTextLineOnScreen(position2di(10,10));
                /** ********************************************* **/
            break;
            case 1:
                /** TEST 1 : affiche une image sur laquelle on a blitté 2 textes  **/
                drawImageOnScreen(testblit, position2di(0,0), driver);
                /** ************************************************************* **/
            break;
        }

        // dessine la frame à l'écran
        driver->endScene();
    }
    // libère les ressources d'Irrlicht
    device->drop();

    return 0;
}