Bonjour à tous, je suis actuellement en train de créer des classes afin de pouvoir afficher du texte en utilisant une police bitmap, à chasse fixe ou variable. Bon, je ne suis pas un très bon codeur, au contraire, et je suis un peu rouillé niveau C++, mais ça compile, c'est déjà pas mal.
Je ne compte pas vous faire la liste de tous les bugs que j'ai subtilement disséminé dans le code avant de les corriger, donc je vais me focaliser sur le bug qui m'amène à poster sur ce forum, c'est à dire que au moment d'afficher mon texte, au lieu d'avoir mes splendides caractères (enfin, tout est relatif), j'ai les superbes rectangles blancs qui m'indiquent que il y a un endroit où ça passe pas avec ma texture.
Je vais expliquer brièvement le fonctionnement ; en gros, j'ai trois classes, une classe de fonte, qui contient la texture de la fonte, un tableau avec la liste des caractères supportés, les dimensions des caractères, une classe de glyphe, qui contient un char, un sprite positionné et dimensionné sur une texture donnée, une classe de texte, qui contient un vector de glyphes et des informations telles que la chaîne de caractère qu'il représente. En fait, la classe de texte va demander à la classe de fonte de lui fournir un glyphe dont le sprite représente le caractère, va faire ça sur toute la chaîne de caractères et les positionner.
Voilà, j'espère que j'ai pas été trop flou ^^'.
Alors, en testant, j'ai que si je draw un glyphe, ça marche, si je draw le glyphe renvoyé par la fonction de la classe de fonte, ça marche, si je draw un glyphe après lui avoir assigné la valeur renvoyé par la méthode de la classe de fonte, ça marche, par contre rectangle blanc dès que je draw la classe de texte (un par caractère, hein, on distingue bien la taille des mots et des caractères, donc la géométrie du sprite passe).
Voici le code très allégé de mes 3 classes et considérant que la police est à chasse fixe (j'ai aussi enlevé les méthodes qui chargent les fichiers de fonte, les draw, les tonnes d'accesseurs et d'autres trucs inutiles, mais je sais pas si ça va aider à la compréhension ou avoir l'effet inverse), si jamais, je les posterais en entier mais je pensais que ça serait trop lourd à lire :
#include "bitmapfont.h"
BitmapFont::BitmapFont()
{
m_nbchar = 0;
m_sizex = 0;
m_sizey = 0;
/* Pour info, deux autres attributs qui nous intéressent sont déclaré comme suit dans le .h :
sf::Texture m_bitmap;
char m_chartable[10000];
*/
}
BitmapGlyph BitmapFont::bchar(char A)
{
BitmapGlyph glyph;
glyph.loadtexture(m_bitmap);
int i = 0;
while(m_chartable[i] != A && i < m_nbchar)
{
i++;
}
if(i >= m_nbchar)
{i = 0;}
glyph.setchar(m_chartable[i]);
glyph.setY(m_sizey);
if(m_monospaced)
{
glyph.setX(m_sizex);
glyph.setsprite((m_sizex+1)*(i%10), (m_sizey+1)*(i/10));
}
else
{
glyph.setX(m_rsizex[i]);
glyph.setsprite((m_rsizex[i]+1)*(i%10), (m_sizey+1)*(i/10));
}
return glyph;
}
#include "bitmapglyph.h"
BitmapGlyph::BitmapGlyph()
{
m_char = ' ';
m_sizex = 0;
m_sizey = 0;
}
BitmapGlyph::BitmapGlyph(const BitmapGlyph& other)
{
m_sprite = other.m_sprite;
m_char = other.m_char;
m_sizex = other.m_sizex;
m_sizey = other.m_sizey;
}
BitmapGlyph& BitmapGlyph::operator=(const BitmapGlyph& other)
{
m_sprite = (other).m_sprite;
m_char = (other).m_char;
m_sizex = (other).m_sizex;
m_sizey = (other).m_sizey;
}
void BitmapGlyph::loadtexture(sf::Texture& font)
{
m_sprite.setTexture(font);
}
void BitmapGlyph::setchar(char A)
{
m_char = A;
}
void BitmapGlyph::setX(int i)
{
m_sizex = i;
}
void BitmapGlyph::setY(int i)
{
m_sizey = i;
}
void BitmapGlyph::setsprite(int a, int b)
{
m_sprite.setTextureRect(sf::IntRect(a, b, m_sizex, m_sizey));
}
#include "bitmaptext.h"
BitmapText::BitmapText()
{
m_font = NULL;
m_posx = 0;
m_posy = 0;
m_sizex = 0;
m_sizey = 0;
m_lastspace = -1;
m_alreadytriedlf = -1;
}
void BitmapText::setfont(BitmapFont font)
{
m_font = &font;
}
void BitmapText::setstring(std::string text)
{
m_string = text;
int i = 0;
m_lastspace = -1;
m_alreadytriedlf = -1;
reformat(0);
}
void BitmapText::reformat() //cette fonction a été laaaaargement simplifiée, en théorie c'est elle qui se charge de récupérer les glyphes et de les positionner, là elle ne positionne plus rien, j'ai juste laissé le code sensible
{
int i = 0;
while(i < m_string.size())
{
m_glyph.push_back((*m_font).bchar(m_string[i]));
}
i++;
}
}
void BitmapText::setsize(int sx, int sy)
{
m_sizex = sx;
m_sizey = sy;
}
Voilà, merci d'avance pour avoir au moins jeté un œil sur mon problème puisque que vous lisez cette phrase =).
Voir les contributions