Crash with 2D array of RectangleShapes

[Fondis]

Hi folks,
I'm having an issue using a 2D array of RectangleShapes. This is based off some of the code in a tutorial, it's meant to create a bunch of RectangleShapes, give them textures and then draw them. For some reason, when the number of tiles (and so the number of rectangleShapes) gets to a certain number, it starts crashing. The debugger says 'Segmentation Fault'. I've been going over my textbooks and a bunch of forum posts but I can't figure it out. Hopefully it's just something silly I forgot.
Has anyone else had experience with this sort of thing? And more generally, is this the 'correct' way to be doing tiled maps? Is there some other way that's more efficient or easier?
Thanks for your time.

#include <SFML/Graphics.hpp>
#include <iostream>
using namespace sf;
using namespace std;

const int TILE_NUMBER_X = 83; //The code works if these two are set to 82.
const int TILE_NUMBER_Y = 83;
const int TILESIZE = 32;
int main()
{
    Texture tileset;
    tileset.loadFromFile("C:/tileset.png");

    RenderWindow window(sf::VideoMode(800, 800), "SFML works!");
    RectangleShape shapes[TILE_NUMBER_X][TILE_NUMBER_Y];


    for (int y = 0; y < (TILE_NUMBER_X); y++)
    {
        for (int x = 0; x < (TILE_NUMBER_Y); x++)
        {
            shapes[x][y].setSize(Vector2f(TILESIZE, TILESIZE));
            shapes[x][y].setPosition(x * TILESIZE, y* TILESIZE);
            shapes[x][y].setTexture(&tileset);
            shapes[x][y].setTextureRect(IntRect(32,32, 32, 32)); //This normally reads from an .tmx file.
        }
    }

    while (window.isOpen())
    {
        Event event;
        while (window.pollEvent(event))
        {
            if (event.type == Event::Closed)
                window.close();
        }

        window.clear();
       (for (int x = 0; x < (TILE_NUMBER_X); x++)
        {
            for (int y = 0; y < (TILE_NUMBER_Y); y++)
                {
                    window.draw(shapes[x][y]);
                }
        }
        window.display();
    }


    return 0;
}
 

Oh, I meant to post this in graphics. Sorry about that.

[eXpl0it3r]

Run it in a debugger and see with the call stack where it crashes.

A better way would be to use a 1D vector of vertices and everything with one draw call.
Also don't use "using namespace"!

[Fondis]

Thanks for your reply. This is what the stack looks like, but I'm not really sure how to interpret it.
I'll definitely look into the vertices method, I think I remember seeing a tutorial for it somewhere on the site.

[eXpl0it3r]

Sounds like a graphics driver issue, try to update it.

[Fondis]

So after updating my graphics drivers, the call stack looks like this:

[Stauricus]

sounds like you're trying to alocate more memory in a single stack than your computer can handle (or something like that, i'm not really into these low level things). try using vectors instead of arrays.

//remove this:
RectangleShape shapes[TILE_NUMBER_X][TILE_NUMBER_Y];

//and add this in the same line:
std::vector< std::vector<RectangleShape> > shapes;
shapes.resize(TILE_NUMBER_X);
for(int n=0; n<TILE_NUMBER_X; n++){
    shapes[n].resize(TILE_NUMBER_Y);
}

obs: you'll need

#include <vector>

.

[Fondis]

This seems to have fixed the problem. Thanks very much to both of you.

[eXpl0it3r]

I still advise you to use a vector of vertices or at least a 1D vector of RectangleShapes, the 2D to 1D mapping is rather easy.

[Nexus]

Yes. In general, a nested std::vector is rather inefficient and needs a lot of memory. If don't need the performance to resize very often along one dimension, I'd recommend using a 1D container and mapping indices. Iteration will be faster on a contigous block of memory, you'll have fewer reallocations and there will only be unused elements along one dimension.

See also: http://en.sfml-dev.org/forums/index.php?topic=12989.msg90955#msg90955