Discussion :

[Ch@hine]

Bonjour,

Par dessus une scène 3D générée avec openGL, j'écris du texte 2D à l'écran à l'aide de SDL_ttf. Voici 2 captures d'écran de mon programme, la première sans transparence, la seconde avec :


J'aimerais attirer votre attention sur ceci : sur la seconde capture, le texte apparaît plus fin, on remarque même des pixels noirs entre les deux branches du "n" (idem pour le "h"). Comme si la transparence du fond avait débordé de quelques pixels sur le texte... Ici le texte est de taile 60, cela reste donc bien lisible, mais avec un texte de taille 10 le texte n'apparaît pratiquement plus...
Voici comment j'ai affiché le texte : à partir d'une surface SDL, j'ai créé une texture openGL (les noms de classes et de méthodes parlent d'eux-mêmes) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
CTexture::CTexture(const CText* text)
{
    unsigned int
        w = (int)floor(pow(2, ceil(log(text->getWidth()) / log(2)))),
        h = (int)floor(pow(2, ceil(log(text->getHeight()) / log(2))));
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32
        RMask = 0xff000000,
        GMask = 0x00ff0000,
        BMask = 0x0000ff00,
        AMask = 0x000000ff;
 
#else
    Uint32
        RMask = 0x000000ff,
        GMask = 0x0000ff00,
        BMask = 0x00ff0000,
        AMask = 0xff000000;
#endif
 
    SDL_Surface *temp = SDL_CreateRGBSurface
    (
        SDL_HWSURFACE,
        w,
        h,
        32,
        RMask,
        GMask,
        BMask,
        AMask
    );
 
    if (!temp)
    {
        SDL_FreeSurface(temp);
 
        cerr << "Fatal error : unable to create texture from SDL surface : " << SDL_GetError() << endl;
        bool error;
        throw error;
    }
 
    SDL_Rect position;
    position.x = 0; position.y = h - text->getHeight();
 
    CSurface temp2(temp);
    SDL_Color color;
    color.r = 0; color.g = 0; color.b = 0;
    temp2.fill(color);
 
    text->blit(&position, &temp2);
 
    temp2.setColorKey(SDL_SRCCOLORKEY, color);
    temp2.displayFormatAlpha();
 
    glGenTextures(1, &texture);
    this->bind();
 
    gluBuild2DMipmaps(GL_TEXTURE_2D, 4, temp2.getWidth(), temp2.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, temp2.getPixels());
    //glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, temp2.getWidth(), temp2.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, temp2.getPixels());
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

Lors de l'affichage, j'active ponctuellement l'alpha-test comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
glAlphaFunc(GL_EQUAL, 1);
    glEnable(GL_ALPHA_TEST);

Auriez-vous une idée ?
D'avance merci !

[bafman]

essaye avec une alpha func à (GL_GREATER,0.8) et en activant le blending, tu devrait obtenir un meilleurs résultat.
le problème ici, c'est que ta font est anti-aliasé, il y a donc des texels qui on un alpha proche de 1 mais pas tout à fait, et il sont supprimé par ton alpha func.
en réduisant la valeur de clipping de l'alpha et en ajoutant du blending (pour éviter les bord noirs), ça devrait résoudre le tout

[Ch@hine]

Bien vu, en effet mon texte a retrouvé de son épaisseur !
Pourtant il ne me semble pas antialiasé : cela ne se voit pas sur le fond noir... D'ailleurs j'ai même utilisé (GL_GREATER, 0.9) et le résultat est le même qu'avec 0.8 ; l'anti-aliasing doit être vraiment très faible.
Par contre si je rajoute le blending, tout mon texte devient semi-transparent... Mais de toute façon l'anti-aliasing semble si faible que je n'ai même pas de bord noir...

Que dois-je mettre dans glBlendFunc() ? Pour l'instant j'ai mis (GL_SRC_ALPHA, GL_ONE).
Et comment se fait-il que mon texte soit si peu antialiasé ? J'ai pourtant utilisé l'écriture blended...

[bafman]

Bien vu, en effet mon texte a retrouvé de son épaisseur !
Pourtant il ne me semble pas antialiasé : cela ne se voit pas sur le fond noir... D'ailleurs j'ai même utilisé (GL_GREATER, 0.9) et le résultat est le même qu'avec 0.8 ; l'anti-aliasing doit être vraiment très faible.
Par contre si je rajoute le blending, tout mon texte devient semi-transparent... Mais de toute façon l'anti-aliasing semble si faible que je n'ai même pas de bord noir...

Que dois-je mettre dans glBlendFunc() ? Pour l'instant j'ai mis (GL_SRC_ALPHA, GL_ONE).
Et comment se fait-il que mon texte soit si peu antialiasé ? J'ai pourtant utilisé l'écriture blended...

ça dépend de ton ficher de font aussi... Comme tu étend beaucoup ta font, si la fonte n'est pas bien faite, il est possible que tu te retrouve avec une font peut anti-aliasé (car géré en petite taille dans le fichier), et ensuite étendu, d'ou l'aliasing.

[Ch@hine]

Après quelques corrections, j'ai à présent bien un texte antialiasé.
Demeure le problème du texte semi-transparent :

Si j'enlève le blending, j'ai en effet des bords noirs plutôt désagréables...
Aussi oserai-je réitérer ma question : que rentrer comme argument à la fonction glBlendFunc() ?

[bafman]

GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA

[Ch@hine]

Je ne remarque pas vraiment de changement par rapport au "sans blending", vois par toi-même :

Si on ne peut guère faire mieux, dis-le moi, que j'arrête de chercher pour rien .

[bafman]

en fait, le problème, c'est que tu fait un rendu de ta font dans sdl_ttf avec unn fond noir, tu a donc forcement du noir qui apparait sur le rouge. tu doit pouvoir faire un rendu blanc sur blanc, et, en utilisant l'alpha et la couleur des vertex, tu devrait obtenir ce que tu souhaite...

[Ch@hine]

Je ne saisis pas ce que tu veux dire par "un rendu blanc sur blanc", peux-tu expliciter stp ? Car tout ce que j'ai compris c'est "écrire blanc sur un fond blanc", et ça n'a pas de sens bien sûr !
Quant à la couleur, qu'elle soit appliquée aux vertices ou directement par SDL ne change rien au rendu final...

[bafman]

Je ne saisis pas ce que tu veux dire par "un rendu blanc sur blanc", peux-tu expliciter stp ? Car tout ce que j'ai compris c'est "écrire blanc sur un fond blanc", et ça n'a pas de sens bien sûr !
Quant à la couleur, qu'elle soit appliquée aux vertices ou directement par SDL ne change rien au rendu final...

justement, c'est bien un rendu blanc sur fond blanc... mais si tu prend en compte l'alpha, tu pourra quand même voir le texte. et le fait d'utiliser la couleur des vertex permet justement de colorer notre texture blanche sans avoir les effets de bordure des texture coloré par la SDL...

[Ch@hine]

Hmm oui je vois ce que tu veux dire...
Il me faut dire à SDL de distinguer, au niveau de la transparence, les pixels blancs du texte des pixels blancs du fond... La seule idée qui m'est venue a été de mettre un fond _presque_ blanc, ce qui donne le résultat suivant :

Etant donné que la couleur du texte est la même que celle du fond, on ne distingue plus les pixels antialiasés des autres... J'ai donc perdu mon antialiasing
As-tu une meilleure idée ?

[bafman]

normalement, avec un fond totalement blanc, si l'alpha est lui aussi anti aliasé par la SDL, tu devrait obtenir le résultat souhaité.
essaye aussi en désactivant l'alpha test et en ne gardant que le blending.

[Ch@hine]

si l'alpha est lui aussi anti aliasé par la SDL

Je crois bien que non justement, sinon mes pixels noirs du début auraient été partiellement transparents et ça aurait donné l'effet recherché dès le début...
J'ai essayé de désactiver l'alpha-test, et ô surprise, ça ne change rien !

Si la SDL n'est pas capable d'antialiaser l'alpha, je me demande si je ne vais pas coder moi-même la fonction qui le fait, ça ne doit pas être bien difficile...

[bafman]

est ce que tu utilise bien STD_ttf_RenderText_Blended ? si ce n'est pas le cas, efectivement tu ne va pas avoir d'alpha dans ton rendu de texte.
tu a un exemple d'utilisation de SDL_ttf ici

[Ch@hine]

J'utilise TTF_RenderText_Blended(), et j'ai déjà lu ta classe auparavant, elle est trop avancée pour moi je m'y perds... Je constate juste que tu appliques la fonction flipSurface(), ce qui, quand je l'essaie dans mon programme, a pour effet de retourner mon texte ! Normal ?!

[bafman]

J'utilise TTF_RenderText_Blended(), et j'ai déjà lu ta classe auparavant, elle est trop avancée pour moi je m'y perds... Je constate juste que tu appliques la fonction flipSurface(), ce qui, quand je l'essaie dans mon programme, a pour effet de retourner mon texte ! Normal ?!

le flip surface, c'est juste parce que dans mon moteur, l'origine des textures est en bas a gauche et que la SDL crée des textures avec l'origine en haut a gauche. Donc plutôt que d'inverser les coordonnées de textures, j'inverse la texture.

[Ch@hine]

cf http://www.developpez.net/forums/sho...d.php?t=302275
Je ne comprends plus du tout : je fais exactement comme sur ce lien mais chez moi rien ne s'affiche... Déjà pour commencer, si je ne fais pas un SDL_FillRect(), mon texte ne se blitte même pas sur ma surface redimensionnée ! Ensuite glTexImage2D() me renvoie un rectangle blanc en texture !

[lorannt]

Salut,

J'ai pas mal galéré aussi pour l'affichage correcte de texte, donc bien qu'étant débutant en OpenGL je me permet de poster la solution que j'utilise (qui est inspirée du code de Neverball).

Comme le propose Bafman il s'agit de générer dans un premier temps le texte en blanc avec STD_ttf_RenderText_Blended; le secret c'est ensuite d'utiliser l'environnement GL_MODULATE au lieu de GL_DECAL, ce qui permet d'utiliser la couleur et l'alpha de tes vertex pour le rendu final du texte.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
    SDL_Color c = { 0xFF, 0xFF, 0xFF, 0xFF };
    SDL_Surface *s1 = TTF_RenderUTF8_Blended(font, text, c);
 
    if (s1)
    {
        int w2 = next_power_of_two(s1->w);
        int h2 = next_power_of_two(s1->h);
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32 r_mask = 0xFF000000;
    Uint32 g_mask = 0x00FF0000;
    Uint32 b_mask = 0x0000FF00;
    Uint32 a_mask = 0x000000FF;
 
#else
    Uint32 r_mask = 0x000000FF;
    Uint32 g_mask = 0x0000FF00;
    Uint32 b_mask = 0x00FF0000;
    Uint32 a_mask = 0xFF000000;
#endif
        SDL_Surface *s2 = SDL_CreateRGBSurface(SDL_SWSURFACE, w2, h2,
                                   32, r_mask, g_mask, b_mask, a_mask);
 
        if (s2)
        {
            SDL_SetAlpha(s1, 0, 0);
            SDL_BlitSurface(s1, 0, s2, 0);
 
            glGenTextures(1, &texture);
            glBindTexture(GL_TEXTURE_2D, texture);
 
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, s2->w, s2->h, 0,
                         GL_RGBA, GL_UNSIGNED_BYTE, s2->pixels);
 
            SDL_FreeSurface(s2);
        }
 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    }

Il faut activer le blending, et utiliser la fonction classique glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA). Pas besoin d'activer l'alpha test. Avec cette solution, la couleur et l'alpha du texte est uniquement déterminée par ce que tu assignes à tes vertex: toutes les combinaisons sont possibles, y compris des dégradés.

[Ch@hine]

J'ai suivi ta procédure comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
CTexture::CTexture(const CText* text)
{
    text->saveBMP("OriginalText.bmp");
 
    unsigned int
        w = (int)floor(pow(2, ceil(log(text->getWidth()) / log(2)))),
        h = (int)floor(pow(2, ceil(log(text->getHeight()) / log(2))));
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32
        RMask = 0xff000000,
        GMask = 0x00ff0000,
        BMask = 0x0000ff00,
        AMask = 0x000000ff;
 
#else
    Uint32
        RMask = 0x000000ff,
        GMask = 0x0000ff00,
        BMask = 0x00ff0000,
        AMask = 0xff000000;
#endif
 
    SDL_Surface *temp = SDL_CreateRGBSurface
    (
        SDL_SWSURFACE,
        w,
        h,
        32,
        text->getRMask(),
        text->getGMask(),
        text->getBMask(),
        text->getAMask()
    );
 
    if (!temp)
    {
        SDL_FreeSurface(temp);
 
        cerr << "Fatal error : unable to create texture from SDL surface : " << SDL_GetError() << endl;
        bool error;
        throw error;
    }
 
    //SDL_Rect position;
    //position.x = 0; position.y = h - text->getHeight();
 
    SDL_SetAlpha(temp, 0, 0);
 
    CSurface temp2(temp);
    temp2.saveBMP("temp2.bmp");
 
    text->blit(0, &temp2, 0);
    temp2.saveBMP("temp2blit.bmp");
 
    //temp2.setColorKey(SDL_SRCCOLORKEY, color);
    //temp2.displayFormatAlpha();
 
    glGenTextures(1, &texture);
    this->bind();
 
    //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, temp2.getWidth(), temp2.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, temp2.getPixels());
    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, temp2.getWidth(), temp2.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, temp2.getPixels());
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    CTexture::CTexture(const CText* text)
{
    text->saveBMP("OriginalText.bmp");
 
    unsigned int
        w = (int)floor(pow(2, ceil(log(text->getWidth()) / log(2)))),
        h = (int)floor(pow(2, ceil(log(text->getHeight()) / log(2))));
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    Uint32
        RMask = 0xff000000,
        GMask = 0x00ff0000,
        BMask = 0x0000ff00,
        AMask = 0x000000ff;
 
#else
    Uint32
        RMask = 0x000000ff,
        GMask = 0x0000ff00,
        BMask = 0x00ff0000,
        AMask = 0xff000000;
#endif
 
    SDL_Surface *temp = SDL_CreateRGBSurface
    (
        SDL_SWSURFACE,
        w,
        h,
        32,
        text->getRMask(),
        text->getGMask(),
        text->getBMask(),
        text->getAMask()
    );
 
    if (!temp)
    {
        SDL_FreeSurface(temp);
 
        cerr << "Fatal error : unable to create texture from SDL surface : " << SDL_GetError() << endl;
        bool error;
        throw error;
    }
 
    //SDL_Rect position;
    //position.x = 0; position.y = h - text->getHeight();
 
    SDL_SetAlpha(temp, 0, 0);
 
    CSurface temp2(temp);
    temp2.saveBMP("temp2.bmp");
 
    text->blit(0, &temp2, 0);
    temp2.saveBMP("temp2blit.bmp");
 
    //temp2.setColorKey(SDL_SRCCOLORKEY, color);
    //temp2.displayFormatAlpha();
 
    glGenTextures(1, &texture);
    this->bind();
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}

Lorsque je désactive le blending, j'obtiens ceci :

Lorsque j'active le blending avec tes paramètres, le texte et son fond disparaissent totalement...

[lorannt]

Est-ce que tu dessines tes vertex avec la bonne couleur (opaque)? Normalement si tu enlèves le glBindTexture dans ton code, tu devrais obtenir des rectangles pleins (et de la couleur voulue) à la place de ton texte.

Aussi, vérifie bien que ton image-texte est en blanc sur fond transparent... À part ça, je vois pas trop d'où pourrait venir le problème...