4 newbie questions (tilemap, textures & animating a sprite)

[Lkcynric]

Hi! I made a small sample game based on tilesets without really looking how its done besides the "Example: tile map" tutorial to see if I could figure it how and learn on the way. I will now be looking into how others have done it to learn more and figure out which way might be better, but until then:

Its a 2d platformer and there are 4 things I'm not sure of and would like to ask more experienced users.

1 - When I create my vertex array, if my tile value is 0, its supposed to not have a tile. So during the creation, when this happens I skip to the next cycle. As far as I understand this means the QUADs will get the default values of (0,0) in all 4 positions and all  4 texture coordinates. That is also what I use when I want to remove a block from the game, i set its QUAD position and texture coords to (0,0).

Is this the way you should do things or there's a better way? Since the example has no such cases i figure it out on my own and might be doing something wrong.

2 - on my map.load (where I create my vertex array) I should be getting the "map" (vector<vector<int>>) NOT by value but as either a pointer or as a reference, right? I honestly need to go read more about pointers & references.

3 - I have N amount of enemy's that walk left and right like SMB Gumba's, to animate them independently of each other, I have 2 choices:
A - Use a vector of clocks, one for each enemy.
B - use 1 clock and vector of SF::time one for each enemy so I can calculate time passed.
Which of the 2 would be optimal? There's a 3rd choice of 1 clock and animate all the enemy's at the same time, but that might not work in all cases, I'm not sure.

4 - To animate a sprite would it be better to use several textures and use the ".setTexture" to change the animation frame or to use 1 texture and use the ".setTextureRact"?
I'm asking performance wise. Probably doesn't make a difference, but I'm curious.

In case you want to look at the tilemap code:

(click to show/hide)

I used the example code from tutorial but added more functionality and changed things here and there.

void TileMap::load(const std::string& tileset, sf::Vector2u tileSize, std::vector<std::vector<int>>& tiles, unsigned int width, unsigned int height) {

        if (!m_tileset.loadFromFile(tileset)) {
                m_hasTexture = false;
                std::cout << "Could not load tilemap texture" << std::endl;
        }
        else {
                m_hasTexture = true;

                // sets the values to be saved
                m_tileSize = tileSize;
                m_width = width;
                m_height = height;

                // resize the vertex array to fit the level size
                m_vertices.clear(); //wasnt originally here
                m_vertices.setPrimitiveType(sf::Quads);
                m_vertices.resize(m_width * m_height * 4);

                // populate the vertex array, with one quad per tile
                for (unsigned int i = 0; i < m_width; ++i) // 20
                        for (unsigned int j = 0; j < m_height; ++j) // 30
                        {
                                // get the current tile number
                                //int tileNumber = tiles[i + j * width][7]; // 0 25 50.... reads the vector from top to bot, then moves to column 2 then 3....
                                int tileNumber = tiles[j][i]; // 0 25 50.... reads the vector from top to bot, then moves to column 2 then 3....

                                if (tileNumber == 0) // so its skips when the tile is a 0
                                        continue;
                                else
                                        tileNumber--;

                                // find its position in the tileset texture
                                int tu = tileNumber % (m_tileset.getSize().x / m_tileSize.x); //  X % (256 / 32) <=> X % 8 -> se X=33 -> 33%8 = 1 (note tileNumber--)
                                int tv = tileNumber / (m_tileset.getSize().x / m_tileSize.x); //                                      -> 33/8 = 4 (pk e int)

                                                                                                                                                        // get a pointer to the current tile's quad
                                sf::Vertex* quad = &m_vertices[(i + j * m_width) * 4];

                                // define its 4 corners
                                quad[0].position = sf::Vector2f(static_cast<float>(i * m_tileSize.x), static_cast<float>(j * m_tileSize.y));
                                quad[1].position = sf::Vector2f(static_cast<float>((i + 1) * m_tileSize.x), static_cast<float>(j * m_tileSize.y));
                                quad[2].position = sf::Vector2f(static_cast<float>((i + 1) * m_tileSize.x), static_cast<float>((j + 1) * m_tileSize.y));
                                quad[3].position = sf::Vector2f(static_cast<float>(i * m_tileSize.x), static_cast<float>((j + 1) * m_tileSize.y));

                                // define its 4 texture coordinates
                                quad[0].texCoords = sf::Vector2f(static_cast<float>(tu * m_tileSize.x), static_cast<float>(tv * m_tileSize.y));
                                quad[1].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * m_tileSize.x), static_cast<float>(tv * m_tileSize.y));
                                quad[2].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * m_tileSize.x), static_cast<float>((tv + 1) * m_tileSize.y));
                                quad[3].texCoords = sf::Vector2f(static_cast<float>(tu * m_tileSize.x), static_cast<float>((tv + 1) * m_tileSize.y));

                        }
        }

}

void TileMap::simpleLoad(std::vector<std::vector<int>>& tiles) {       
        if (!m_hasTexture)
                std::cout << "Couldn't load map, no texture set" << std::endl;
        else if(m_tileSize.x <= 0 && m_tileSize.y <= 0 && m_width <= 0 && m_height <= 0)
                std::cout << "Couldn't load map, sizes not set" << std::endl;             // do i need this? the user cant make this error ocurr only i with code.
        else {

                // resize the vertex array to fit the level size
                m_vertices.clear(); //wasnt originally here
                m_vertices.setPrimitiveType(sf::Quads);
                m_vertices.resize(m_width * m_height * 4);

                // populate the vertex array, with one quad per tile
                for (unsigned int i = 0; i < m_width; ++i) // 20
                        for (unsigned int j = 0; j < m_height; ++j) // 30
                        {
                                // get the current tile number
                                //int tileNumber = tiles[i + j * width][7]; // 0 25 50.... reads the vector from top to bot, then moves to column 2 then 3....
                                int tileNumber = tiles[j][i]; // 0 25 50.... reads the vector from top to bot, then moves to column 2 then 3....

                                if (tileNumber == 0) // so its skips when the tile is a 0
                                        continue;
                                else
                                        tileNumber--;

                                // find its position in the tileset texture
                                int tu = tileNumber % (m_tileset.getSize().x / m_tileSize.x); //  X % (256 / 32) <=> X % 8 -> se X=33 -> 33%8 = 1 (note tileNumber--)
                                int tv = tileNumber / (m_tileset.getSize().x / m_tileSize.x); //                                      -> 33/8 = 4 (pk e int)

                                                                                                                                                                // get a pointer to the current tile's quad
                                sf::Vertex* quad = &m_vertices[(i + j * m_width) * 4];

                                // define its 4 corners
                                quad[0].position = sf::Vector2f(static_cast<float>(i * m_tileSize.x), static_cast<float>(j * m_tileSize.y));
                                quad[1].position = sf::Vector2f(static_cast<float>((i + 1) * m_tileSize.x), static_cast<float>(j * m_tileSize.y));
                                quad[2].position = sf::Vector2f(static_cast<float>((i + 1) * m_tileSize.x), static_cast<float>((j + 1) * m_tileSize.y));
                                quad[3].position = sf::Vector2f(static_cast<float>(i * m_tileSize.x), static_cast<float>((j + 1) * m_tileSize.y));

                                // define its 4 texture coordinates
                                quad[0].texCoords = sf::Vector2f(static_cast<float>(tu * m_tileSize.x), static_cast<float>(tv * m_tileSize.y));
                                quad[1].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * m_tileSize.x), static_cast<float>(tv * m_tileSize.y));
                                quad[2].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * m_tileSize.x), static_cast<float>((tv + 1) * m_tileSize.y));
                                quad[3].texCoords = sf::Vector2f(static_cast<float>(tu * m_tileSize.x), static_cast<float>((tv + 1) * m_tileSize.y));

                        }
        }
}

void TileMap::updateTile(int posX, int posY, unsigned int newValue, sf::Vector2u tileSize, int vecWidth) {

        if (posX > 15) // because its global cords not view cords...
                posX -= 15;
        if (posY > 10)
                posY -= 10;

        sf::Vertex* quad = &m_vertices[(posX + posY * vecWidth) * 4];

        if (newValue == 0) { //removes texture and position
                quad[0].position = sf::Vector2f(0, 0);
                quad[1].position = sf::Vector2f(0, 0);
                quad[2].position = sf::Vector2f(0, 0);
                quad[3].position = sf::Vector2f(0, 0);

                // define its 4 texture coordinates
                quad[0].texCoords = sf::Vector2f(0, 0);
                quad[1].texCoords = sf::Vector2f(0, 0);
                quad[2].texCoords = sf::Vector2f(0, 0);
                quad[3].texCoords = sf::Vector2f(0, 0);

        }
        else { // I never actually tested change from tile X to tile Y.... i should teste this...

                int tu = newValue % (m_tileset.getSize().x / tileSize.x); //  X % (256 / 32) <=> X % 8 -> se X=33 -> 33%8 = 1 (note tileNumber--)
                int tv = newValue / (m_tileset.getSize().x / tileSize.x); //                                      -> 33/8 = 4 (pk e int)

                        // define its 4 corners
                quad[0].position = sf::Vector2f(static_cast<float>(posX * tileSize.x), static_cast<float>(posY * tileSize.y));
                quad[1].position = sf::Vector2f(static_cast<float>((posX + 1) * tileSize.x), static_cast<float>(posY * tileSize.y));
                quad[2].position = sf::Vector2f(static_cast<float>((posX + 1) * tileSize.x), static_cast<float>((posY + 1) * tileSize.y));
                quad[3].position = sf::Vector2f(static_cast<float>(posX * tileSize.x), static_cast<float>((posY + 1) * tileSize.y));

                // define its 4 texture coordinates
                quad[0].texCoords = sf::Vector2f(static_cast<float>(tu * tileSize.x), static_cast<float>(tv * tileSize.y));
                quad[1].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * tileSize.x), static_cast<float>(tv * tileSize.y));
                quad[2].texCoords = sf::Vector2f(static_cast<float>((tu + 1) * tileSize.x), static_cast<float>((tv + 1) * tileSize.y));
                quad[3].texCoords = sf::Vector2f(static_cast<float>(tu * tileSize.x), static_cast<float>((tv + 1) * tileSize.y));

        }
}


void TileMap::setFixedVars(const std::string& tileset, sf::Vector2u tileSize, unsigned int width, unsigned int height) {

        if (!m_tileset.loadFromFile(tileset)) {
                m_hasTexture = false;
                std::cout << "Could not load tilemap texture" << std::endl;
        }
        else {
                m_hasTexture = true;
        }

        m_tileSize = tileSize;
        m_width = width;
        m_height = height;

}

void TileMap::setTilemapTexture(std::string tileset) {
        if (!m_tileset.loadFromFile(tileset)) {
                m_hasTexture = false;
                std::cout << "Could not load tilemap texture" << std::endl;
        }
        else {
                m_hasTexture = true;
        }
}


void TileMap::draw(sf::RenderTarget& target, sf::RenderStates states) const {
        // apply the transform
        states.transform *= getTransform();

        // apply the tileset texture
        states.texture = &m_tileset;

        // draw the vertex array
        target.draw(m_vertices, states);
}
 

[Hapax]

Hi 😊

1. For 'empty' tiles, you can also use a transparent part if the texture and leave the co-ordinates where they would have been if visible.

2. Yes, using a reference here is a good choice unless you actually want to move it or copy it.

3. I'd probably use a global clock and use offset times for everything. Many clocks seem like a waste but they aren't much more than time offsets anyway. As long as they aren't being constantly created and destroyed, multiple clocks seems acceptable.

4. Definitely not setTexture. Use setTextureRect instead. Setting a texture can affect performance (possibly severely if done a lot) whereas setting the texture rectangle is 'free'.

[Laurent]

4. Definitely not setTexture. Use setTextureRect instead. Setting a texture can affect performance (possibly severely if done a lot) whereas setting the texture rectangle is 'free'.

Note that in practice, this is rarely true. To make a difference, the animated character would have to be the only thing to be drawn; or you would have to put other stuff into the texture (ie. make an atlas).

If it's not clear, here is the sequence of texture switch when using one texture per frame:

draw(something_using_texture_A);
draw(animation_texture_frame_x);
draw(something_using_texture_B);
...
 

And now using a single animation texture:

draw(something_using_texture_A);
draw(animation_texture);
draw(something_using_texture_B);
...
 

... no difference.

[Lkcynric]

Ok, thank you both! Short and easy to understand.

[Hapax]

No problem; you are welcome.

To be clear, I did use the word "can" to show that there are times when it would not affect performance.
Although, to be fair, I don't think it's "rare" to draw multiple things from the same texture and this is when it texture rectangle becomes an improvement. Texture rectangle is the same in the other case so using a texture rectangle as default is probably the safest bet.