#0 

12-09-2012 22:30:40

johnplayer
Habitué
Date d'inscription: 30-09-2007
Messages: 431

J'ai fait une classe permettant d'utiliser des fonts *.ttf dans Irrlicht à l'aide d'image.
Une simple conversion IImage vers ITexture permettrait d'insérer du texte dans un IGUIImage.

Cette classe offre pas mal de possibilités pour peut qu'on ait de l'imagination. Il a des optimisations à faire mais ça je vous laisserez
les faire, j'ai d'ailleurs commencé une v2 de mon côté. Le but est surtout d'intégrer n'importe quelle police sans se prendre la tête
avec les "polices d'Irrlicht".

Cette classe utilise Freetype2 pour la gestion des polices. Le code est suffisamment commenté donc je ne rajouterai rien.
Si vous avez des questions, sur l'utilisation n'hésitez pas.

télécharger Freetype2

INFO
info : Il se peut que certains caractères dans le post ne passent pas car j'y ai mis du japonais pour montrer que n'importe quel texte dans n'importe quelle langue passe.
Sous windows, il suffit d'installer les langues orientales dans "région et langue".


TextImage.hTextImage.cppmain.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#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
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 '\n'
        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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456

#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 '\n'
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 == '\n') return position + position2di(0, 1.4*getFontSize());
    if(caractere == '\t') 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 == '\n') return -1;
    if(caractere == '\t') 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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#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
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 = "";
    // 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("", "", 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("Des chaînes avec des caractères spéciaux dans la barre de titre.");
    // création des texte
    TextImage testblittext1("Test imageonscreen : Des caractères spéciaux et japonais. 日本語はむずかしい。", "../medias/umeplus-gothic.ttf", 16);
    testblittext1.setTextColor(SColor(255,255,0,0));
    TextImage testblittext2("../medias/comparaison 2048px vs 4096px shadowmap.png", "testblit : shadow Map 2048 x 2048 px", 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;
}

core i7 4970K @ 4GHz - 32GB ddr3 19200(2400MHz) - ssd samsung 840 evo 250GB - GTX1080Ti (4K) - Cooler master storm stryker blanc.
"L'alcool, c'est comme Activia, c'est actif à l'intérieur et ça se voit à l'extérieur."

Hors ligne


#1 

13-09-2012 10:07:20

johnplayer
Habitué
Date d'inscription: 30-09-2007
Messages: 431

Il y a des optimisations intéressantes à faire, j'ai simplifié la méthode d'encodage "stringUTF8toUNICODE". La fonction fait 54 lignes (commentaires compris) au lieu de 104. J'ai aussi supprimer pas mal de calculs redondants. Bon, par contre je ne poste pas le nouveau code car le but était de vous montrer comment utiliser Freetype2 sans vouloir faire de tuto. Il y a aussi quelques amélioration que je suis entrain d'apporté comme le support de texte multiligne avec wordwrap, le blit de texte sur texture...


core i7 4970K @ 4GHz - 32GB ddr3 19200(2400MHz) - ssd samsung 840 evo 250GB - GTX1080Ti (4K) - Cooler master storm stryker blanc.
"L'alcool, c'est comme Activia, c'est actif à l'intérieur et ça se voit à l'extérieur."

Hors ligne


#2 

13-09-2012 14:07:45

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 904
Corrections: 2
Site web

c'est une approche intéréssant en tout cas, mais pourquoi ne pas avoir fait un loader ttf vers IGUIFontBitmap* en fonction de la taille demander ? cela rendais ton code utilisable pour tout élément irrlicht (statique text, combo box, button, ...)
c'est dommage, mais  ce seras surment utils éffectivement comme exemple d'utilisation de freetype avec irrlicht

edit: pourquoi utilise un IImage au lieux d'une ITexture ? cela permetrais de bliter avec l'acceleration materiel directement, au lieux d'un pixel/pixel ...

bref merci pour le partage johnplayer wink

Hors ligne


#3 

13-09-2012 15:56:57

johnplayer
Habitué
Date d'inscription: 30-09-2007
Messages: 431

Je ne l'ai pas conçu dans le but de l'intégrer à la gui d'Irrlicht, c'était juste une idée comme ça. Je l'utilise afin d'afficher du texte dans une image ou une texture pour l'appliquer à l'écran ou sur un élément 3D. Pourquoi? Tout simplement parce qu'il y a des éléments ayant des textes dynamiques (ex: un panneau d'affichage, un compte à rebours, des infos dans un HUD...). Irrlicht utilise une font non standard et restreinte dans son nombre de caractères. Au final, cette classe sert à afficher un texte sur n'importe quel élément 2D ou 3D du jeu. Bien sûr, le code que j'ai donné ne contient pas toutes les fonctionnalités de celui que je fais actuellement mais il donne de bonnes bases à ceux qui ont envie de faire quelque chose avec Freetype2.

Pour les ITexture au lieu des IImage, je suis tout à fait d'accord, d'ailleurs je code le support des ITexture actuellement. Mais ce bout de code est loin d'être optimisé, il est là pour montrer comment utiliser Freetype2 et les fonctions "toutes faites" de IImage permettent de rendre plus facilement compréhensible le code. Après, suffit de coder un équivalent de getpixel et setpixel pour une texture, rien de bien méchant, il y en a pour 5 minutes.

PS :
Sinon j'aurais bien donné un code plus optimisé et complet mais il y a trop de personnes qui ne font que prendre sans jamais donner.  Donc celui qui veut vraiment faire quelque verra en ce code un tuto et demandera un peut d'aide pour l'améliorer, tandis que celui qui veut juste un code "tout fait" se contentera de ce qu'il y a. Parce qu'on ne progresse pas en faisant du "copier-coller"


core i7 4970K @ 4GHz - 32GB ddr3 19200(2400MHz) - ssd samsung 840 evo 250GB - GTX1080Ti (4K) - Cooler master storm stryker blanc.
"L'alcool, c'est comme Activia, c'est actif à l'intérieur et ça se voit à l'extérieur."

Hors ligne


#4 

13-09-2012 17:13:36

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 904
Corrections: 2
Site web

bien bien, je n'avais pas envisager cette optique d'utilisation wink

pour ton code interne:
ne pensse tu pas qu'alors un render to texture serais plus opti ? dans les deux sens du terme (materiel et utilisation) ?
tu garderais alors la possibiliter d'utiliser ton ttf dans la gui mais également de blitter nimporte qu'elle font ttf ou bitmap en 3d

enfin certe si ton code est déjà intégré a ton architecture ça ne vaux surment pas la pène de remêtre en question ceci

(PS >> +1)

Hors ligne


#5 

13-09-2012 17:39:56

johnplayer
Habitué
Date d'inscription: 30-09-2007
Messages: 431

Je ne pense pas que ça irai car j'utilise le canal alpha. En fait, freetype renvoie un bitmap à 256 niveaux de gris. Moi je l'utilise en canal Alpha pour que mes 256 niveaux de gris deviennent 256 niveaux d'alpha. Ensuite les canaux RGB contiennent la couleur du texte. Enfin, quand je blitte mon texte sur un support,  l'alpha me donne le pourcentage de la couleur finale que représente ma couleur de texte.

ex: alpha= 199 soit 80% de 255
donc couleur finale = 80% couleur texte + 20% couleur support.
C'est du blending, si je ne me trompe pas.Et ça permet de garder l'anti-aliasing du texte même une fois blitté sur un support.

Si je fais un RTT, je perds l'alpha. Enfin, si j'ai saisis ce que tu voulais dire.

Ensuite, pour la gui, autant faire une fonction qui incruste un texte dans un GUIImage qu'on lui donne. Ce sera tout aussi rapide.


core i7 4970K @ 4GHz - 32GB ddr3 19200(2400MHz) - ssd samsung 840 evo 250GB - GTX1080Ti (4K) - Cooler master storm stryker blanc.
"L'alcool, c'est comme Activia, c'est actif à l'intérieur et ça se voit à l'extérieur."

Hors ligne


Options Liens officiels Caractéristiques Statistiques Communauté
Corrections
irrlicht
irrklang
irredit
irrxml
xhtml 1.0
css 2.1
Propulsé par FluxBB
Traduit par FluxBB.fr
Analysé par
880 membres
1424 sujets
11113 messages
Dernier membre inscrit: mandrifidy
61 invités en ligne
Aucun membre connecté
RSS Feed