sf::texture destroyed when in class

[ormenbjorn]

hi! I wanted to have a texture in a class like this:

 
class Thing{
    private:
    sf::Texture texture;
    sf::Sprite sprite;

    public:
    Thing(){
        texture.loadFromFile("file");
        sprite.setTexture(texture);
    }

    void draw(){
        //draw
    }
}
 

but then, the texture is gone in the draw() function and the sprite is white.
When I do

std::cout << &texture << endl;

, nothing shows up.

I have read about how the texture is destroyed if you make it in a function, which is pretty obvious to me, but i'm just loading the texture in a function here, which i think should work?
Thanks

[man'O'war]

Hi,

As long as the object is alive, the texture should be .

How are you drawing it ?

[ormenbjorn]

just with a function similar to this

void draw(RenderWindow &window){
    window.draw(sprite);
}
 

[ormenbjorn]

the class is inheriting another class and being used by another one(not the inherited one), should i post all of the code? it's not that long if i take away the unneeded parts

[man'O'war]

Yes, i would like to see the code

Because i've tested a minimal code, and it's just working fine.

main.cpp

(click to show/hide)

#include <SFML/System.hpp>
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>

#include "thing.h"

int main()
{
    sf::RenderWindow window(sf::VideoMode(500, 500), "SFML");

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

        window.clear();

        t.draw( window );

        window.display();
    }

    return 0;
}
 

Thing.h

(click to show/hide)

#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>

class Thing
{
    private:
        sf::Texture texture;
        sf::Sprite sprite;

    public:
        Thing();
        void draw(sf::RenderWindow& window);


};

Thing.cpp

(click to show/hide)

#include "thing.h"

Thing::Thing(){
    texture.loadFromFile("Bat.png");
    sprite.setTexture(texture);
}

void Thing::draw(sf::RenderWindow &window){
    window.draw(sprite);
}
 

[ormenbjorn]

Here's code that replicates the problem:

main.cpp:

(click to show/hide)

#include <iostream>
#include <Windows.h>
#include <SFML/Graphics.hpp>
#include "Map.h"

using namespace std;
using namespace sf;

int main() {
        RenderWindow window(VideoMode(500, 500), "meow");
        window.setFramerateLimit(5);

        Event events;

        Map map;

        while (window.isOpen()) {

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

                window.clear();
                map.draw(window);
                window.display();
        }
}
 

Map.h:

(click to show/hide)

#pragma once
#include <iostream>
#include <SFML/Graphics.hpp>
#include "Slider.h"
using namespace sf;
using namespace std;

class Map{
private:
        vector<Slider> sliders;

public:
        Map();

        void draw(RenderWindow &window);
};
 

Map.cpp:

(click to show/hide)

#include "Map.h"

Map::Map(){
        sliders.push_back(Slider(Vector2f(0, 0)));
        sliders.push_back(Slider(Vector2f(200, 200)));
}

void Map::draw(RenderWindow &window) {
        sliders[0].draw(window);
        sliders[1].draw(window);
}
 

Slider.h

(click to show/hide)

#pragma once
#include <SFML/Graphics.hpp>
using namespace sf;

class Slider{
private:
        Texture texture;
        Sprite sprite;

public:
        Slider(Vector2f pos);

        void draw(RenderWindow &window);
};
 

Slider.cpp:

(click to show/hide)

#include "Slider.h"

Slider::Slider(Vector2f pos){
        texture.loadFromFile("slider.png");
       
        sprite.setTexture(texture);
        sprite.setPosition(pos);
}

void Slider::draw(RenderWindow &window) {
        window.draw(sprite);
}
 

[man'O'war]

The problem comes from this part

vector<Slider> sliders;

It should be like that.

class Slider{
    private:
        vector<Slider*> sliders;
}


Map::Map(){
    sliders.push_back( new Slider(Vector2f(0, 0)));
    sliders.push_back( new Slider(Vector2f(200, 200)));
}

void Map::draw(RenderWindow &window) {
    sliders[0]->draw(window);
    sliders[1]->draw(window);
}

 

The problem comes from here.

    sliders.push_back(Slider(Vector2f(0, 0)));
 

It is equivalent to:

Slider s1 = Slider(Vector2f(0, 0));
sliders.push_back(s1);
 

You create a Slider s1, The sprite of s1 is pointing to the address of the texture inside s1.
Then you push it into the vector, which creates a copy of it. In that case, the Sprite of the new copy is still pointing to the address of the texture inside s1. And when the constructor goes out of scope, ( finishes ), s1 will be destroyed, and vector(i) will have no texture attached.

[ormenbjorn]

Thank you.

[Jesper Juhl]

I'd say that should probably be

std::vector<std::unique_ptr<Slider>> sliders;