[RÉSOLU une bonne fois pour toute] Code tilemapping

[S66]

Hello,
Il y'a quelques trucs que j'ai pas compris dans l'exemple du tilemapping

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;
    }

1) On utilise m_tileset que pour avoir la longueur du tileset. Mais comment le quad a -t- il la bonne image de tuile ? Il n'y a aucun quad->setTexture(m_tileset); par exemple.
2) À quoi sert texCoords du coup ?

Merci de m'éclairer 

[Laurent]

texCoords sert à déterminer quelle partie de la texture sera mappée sur le quad. Quant à l'utilisation de la texture, c'est dans la fonction draw que ça se passe.

[S66]

Aah, je comprends mieux, merci 

[S66]

Sinon, autre question: j'aimerais faire une map iso à partir de l'exemple de la tilemap en 2d.
Voici mon code:

bool loadIso(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height) {
        if (!m_tileset.loadFromFile(tileset))
            return false;

        m_vertices.setPrimitiveType(sf::Quads);
        m_vertices.resize(width * height * 4);

        for (unsigned int x = 0; x < width; ++x)
            for (unsigned int y = 0; y < height; ++y) {
                sf::Vertex* quad = &m_vertices[(x + y * width) * 4];

                if(x % 2 == 0){ //Nombre Pair
                    //Position des quatre coins
                    quad[0].position = sf::Vector2f(x * tileSize.x,        y * tileSize.y); //tileSize.x = 64, tileSize.y = 32
                    quad[1].position = sf::Vector2f((x + 1) * tileSize.x,  y * tileSize.y);
                    quad[2].position = sf::Vector2f((x + 1) * tileSize.x, (y + 1) * tileSize.y);
                    quad[3].position = sf::Vector2f(x * tileSize.x,       (y + 1) * tileSize.y);
                }else{ //Impair
                    //Position des quatre coins
                    quad[0].position = sf::Vector2f(x * tileSize.x + (tileSize.x/2),        (y * tileSize.y) - (y * (tileSize.y/2)));
                    quad[1].position = sf::Vector2f((x + 1) * tileSize.x + (tileSize.x/2),  (y * tileSize.y) - (y * (tileSize.y/2)));
                    quad[2].position = sf::Vector2f((x + 1) * tileSize.x + (tileSize.x/2), ((y + 1) * tileSize.y) - ((y + 1) * (tileSize.y/2)));
                    quad[3].position = sf::Vector2f(x * tileSize.x + (tileSize.x/2),       ((y + 1) * tileSize.y) - ((y + 1) * (tileSize.y/2)));
                }
                quad[0].texCoords = sf::Vector2f(0, 0);
                quad[1].texCoords = sf::Vector2f(64, 0);
                quad[2].texCoords = sf::Vector2f(64, 32);
                quad[3].texCoords = sf::Vector2f(0, 32);
            }
    }

Mais je ne comprends pas les lignes

m_vertices.resize(width * height * 4);

et

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

Pourquoi x4 ? Ma tuile iso sera de 64x32, 64x32x4 fait un peu plus de 8000... problem.

EDIT: Non, sorry, je viens de voir que c'était  la longueur et largeur de la map x4.
Mais je ne comprends toujours pas le x4

[G.]

Un carré c'est 4 vertices.
Donc pour faire width * height carrés, il te faut width * height * 4 vertices.

[S66]

D'accord. Merci.

[S66]

Bon sinon j'ai the big problem:
J'exécute la fonction loadIso (pas load!), et c'est toujours le petit exemple de tilemapping 2d qui sort.
What's the problem ?
Code:
mainmap.cpp, fonction OnInit

void OnInit()
    {
        const int level[] =
            {
                0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
                1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
                0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0,
                0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0,
                0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
                2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1,
                0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1
            };
        const int levelIso[] = {
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0
        };

            //if (!map.load("tileset.png", sf::Vector2u(32, 32), level, 16, 8))
              //  errCode = 1;
            if (!map.loadIso("tuileiso.png", sf::Vector2u(64, 32), levelIso, 8, 8))
                errCode = 1;
            if (errCode == 1) {
                QFile erreurFile("error.log");
                int errFile = 0;
                erreurText.setString("Impossible de charger tileset.png\nUn message d'erreur a été écrit dans le fichier error.log");

                if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                    errFile = 1;
                    erreurText.setString(L"Impossible de charger tileset.png\nImpossible d'ouvrir un fichier pour écrire l'erreur");
                }

                if (errFile == 0) {
                    QTextStream flux(&erreurFile);
                    flux.setCodec("UTF-8");
                    flux << "===== Erreur =====" << std::endl << "Code d'erreur: 1" << std::endl;
                    flux << "Message d'erreur:" << std::endl << "Impossible de charger l'image tileset.png" << std::endl;
                    flux << "Vérifiez qu'elle se trouve bien dans le même répertoire que l'exécutable." << std::endl << std::endl;
                    flux << "EOF";
                    erreurFile.close();
                }

            }
        //Initialisation et attributs
    }

Qt est fou !

[S66]

J'ai fait un rebuild, et ça a... "presque" marché.