Discussion :

[bisthebis]

Bonjour,

J'ai récemment installé la SFML (bibliothèque de 2D). L'apprivoisement se passe assez bien, c'est simple, agréable, et il y a des tutos officiels en français. Bref, l'amour total !
Dans un des ces tutoriels, un code d'exemple est fourni (une classe TileMap) me laisse perplexe.

Dans la méthode load, cette ligne ci me laisse perplexe : sf::Vertex* quad = &m_vertices[(i + j * width) * 4];
Il faut savoir que l'attribut m_vertices est de type VertexArray. Les VertexArray sont simplement des vecteurs contenant des Vertex (dans le code source," std::vector<Vertex> m_vertices;" est un des deux seuls attributs non-hérités de VertexArray). Dans les VertexArray, l'opération [] a été surchargée pour retourner une référence (ou une adresse ? Dans le prototype c'est "Vertex&" mais ca me laisse toujours perplexe cette confusion) du Vertex correspondant.

Donc, dans la ligne précitée, on crée donc un pointeur Vertex sur une composant d'un attribut d'un VertexArray. (Ca me laisse perplexe niveau encapsulation mais bon)
Ceci m'incite à penser que Vertex& retourne une adresse et non une référence mais j'en jurerais pas. Mélanger référence et pointeur me perturbe hautement.

Ce que je ne comprends pas, c'est que ledit Vertex* quad est utilisé plus loin avec des crochets... Et avec des points et non des ->

Est-ce que quelqu'un comprend ce charabia ?

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
class TileMap : public sf::Drawable, public sf::Transformable
{
public:
 
    bool load(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
    {
        // on charge la texture du tileset
        if (!m_tileset.loadFromFile(tileset))
            return false;
 
        // on redimensionne le tableau de vertex pour qu'il puisse contenir tout le niveau
        m_vertices.setPrimitiveType(sf::Quads);
        m_vertices.resize(width * height * 4);
 
        // on remplit le tableau de vertex, avec un quad par tuile
        for (unsigned int i = 0; i < width; ++i)
            for (unsigned int j = 0; j < height; ++j)
            {
                // on récupère le numéro de tuile courant
                int tileNumber = tiles[i + j * width];
 
                // on en déduit sa position dans la texture du tileset
                int tu = tileNumber % (m_tileset.getSize().x / tileSize.x);
                int tv = tileNumber / (m_tileset.getSize().x / tileSize.x);
 
                // on récupère un pointeur vers le quad à définir dans le tableau de vertex
                sf::Vertex* quad = &m_vertices[(i + j * width) * 4];
 
                // on définit ses quatre coins
                quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
                quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
                quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
                quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);
 
                // on définit ses quatre coordonnées de texture
                quad[0].texCoords = sf::Vector2f(tu * tileSize.x, tv * tileSize.y);
                quad[1].texCoords = sf::Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
                quad[2].texCoords = sf::Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
                quad[3].texCoords = sf::Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
            }
 
        return true;
    }

[Bysbobo]

Bonjour,

Je vais me tenter à risquer une réponse donc n'hésites pas à me corriger ou à me dire si ce n'est pas très clair.

Les VertexArray sont des "tableaux" de Vertex. En fonction de la primitive que tu cherches à utiliser, chaque case de ta table n'aura pas le même nombre de points.

Code :

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

m_vertices.setPrimitiveType(sf::Quads);

Dans le lien que tu as renseigné, les quads sont des carrés et pour dessiner un carré il te faut 4 points (je ne t'apprends rien, j'espère :P).
Donc, en résumé, m_vertices est une table contenant 4 points contigus, chaque point ayant leur coordonnées x et y, une couleur et une texture.

Code :

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

sf::Vertex* quad = &m_vertices[(i + j * width) * 4];

Tu récupères l'adresse du quad que tu cherches à modifier et le code d'après accède aux éléments à partir de cette adresse.
Effectivement, tu peux penser à utiliser des -> et non des . mais tu accèdes au premier vertex sur les 4 possibles.

Code :

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

1
2
3
4
5
// on définit ses quatre coins
quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);

Cette partie ne fait qu'accéder à une case de ton tableau de Vertex qui donne accès à un autre tableau de 4 cases et tu modifies les attributs position de chaque vertex formant ton quad.

[LittleWhite]

Bonjour,

L'opérateur [] de VertexArray retourne bien des références sur les éléments du tableau. Le fait d'écrire : &myRef, permet d'obtenir un pointeur.

Code :

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

sf::Vertex* quad

C'est un pointeur, cela était facile. Mais il est utilisé comme tableau. Donc quad[0] donne bien l'élément du tableau (ou, plus précisément, l'élément pointé par quad, en position 0).

Je ne sais pas si je vous aide.