Displaying more-and-more (sf::)texts slows the program down rapidly.

[val]

Hello.

I'am trying to make a roguelike game, and i'll need quite a few sf::Texts to display messages, the interface, the dungeon, etc. When i tried to add more string to display the game dropped from ~400 fps to ~100 after 5-6 extra texts. Adding ten or so slowed the game down to 30-40 fps. I made a "small" example program in the vein of what iam doing in my main program. Here i start with 4000 or so fps and adding 20 sf::Texts to display slows it down to ~200. I tried appending text to a single string to display with one sf::Text, but the resoult was the same.  Is displaying text this costly? Or iam doing something wrong?

Test Code Below.

(click to show/hide)

#define SFML_STATIC
#include <SFML/Graphics.hpp>
#include <SFML/System.hpp>
#include <SFML/Window.hpp>
#pragma comment(lib, "sfml-graphics-s-d.lib")
#pragma comment(lib, "sfml-window-s-d.lib")
#pragma comment(lib, "sfml-system-s-d.lib")

#include <string>
#include <vector>
using namespace std;

void drawFps(sf::RenderWindow &wnd, sf::Clock &clock, sf::Font &font){
        float currentTime = clock.restart().asSeconds();
    float fps = 1.f / currentTime;
        sf::Text tx;
        tx.setString(to_string((int)fps).c_str());
        tx.setPosition(600.0f,500.0f);
        tx.setFont(font);
        tx.setCharacterSize(16);
        wnd.draw(tx);
}

class Messages{
public:
        static sf::Vector2i position;
        static vector<string> messages;
        static void AddDummyMessage(){
                messages.push_back("This is a test message, because test.");
        }
};

sf::Vector2i position = sf::Vector2i(0,0);
vector<string> Messages::messages;

void DisplayMessages(sf::RenderWindow &wnd, sf::Font &font){
        sf::Text tx;
        tx.setFont(font);
        tx.setCharacterSize(16);               
        int offset = 0;
        for(auto e : Messages::messages){
                tx.setPosition(position.x * 16, position.y * 16 + offset++*16);
                tx.setString(e);
                wnd.draw(tx);
        }
}

int main()
{
        sf::RenderWindow wnd(sf::VideoMode(800,600,32), "Test");
        sf::Event evt;
        sf::Font font;
        font.loadFromFile("arial.ttf");
        sf::Clock clock;

        while(wnd.isOpen()){
                wnd.clear();
                while(wnd.pollEvent(evt)){
                        if(evt.type == sf::Event::KeyPressed && evt.key.code == sf::Keyboard::Space){
                                Messages::AddDummyMessage();
                        }
                }
                DisplayMessages(wnd, font);
                drawFps(wnd, clock, font);
                wnd.display();
        }  
}
 

[Ixrec]

This isn't a very realistic test since you're constructing the sf::Text objects and setting their strings and fonts every single frame.  In particular, all the glyph rendering is being redone every single frame.  Normally you do that once and then draw the same sf::Text for several frames in a row (since the humans need time to actually read the text).

Your fps counter is also constructing sf::Text objects from scratch every single time, so the time it takes to print the number might be non-negligible.  Try printing directly to std::cout to cut down on that overhead.  Ideally, you would do no printing at all most frames and only output a rolling average fps maybe once every few seconds.

Also note that 4000 fps vs 200 fps is a bit meaningless, since super-high fps like 4000 usually indicate a program that does absolutely nothing, not a program with amazing performance.



P.S. It's generally a bad idea to use #pragmas for linking.  That sort of information should be part of your build system, not your source code.  Otherwise your source code ends up tightly coupled to your current build system and hard to port later on.

[binary1248]

sf::Text isn't necessarily the cheapest thing to draw. They consist of multiple textured quads, so there's that.

However, you would have to draw a truly ludicrous amount of sf::Texts for you to notice anything really game-breaking. For all "reasonable" intents and purposes, the performance is sufficient. This might even improve in the future.

Like Ixrec already said, the reason for the poor performance is not because sf::Text is really expensive to draw, but because your test throws it into an unrealistic worst-case scenario. In typical "well-designed" games, you would not have to recreate so many sf::Texts every frame. I even go so far as to say that your test performs so slowly not because of the drawing itself, but because of the amount of memory allocations and constructor/destructor calls, so basically "standard C++ stuff". If you tested any other library this way, you would probably get similar results.

I maintain SFGUI, so I can say I've had my share of benchmarking sf::Text in the past. To make sf::Text the bottleneck of your game, you would probably have to draw so much text on your screen, I would feel sorry for the player that has to read all of it .

[Polyfructol]

All that have been said is absolutely right, but I was curious and I've made the correction by myself. So there you are:

(click to show/hide)

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

#include <string>
#include <vector>

void DrawFps(sf::RenderTarget &wnd, sf::Clock &clock, sf::Font &font){
    float currentTime = clock.restart().asSeconds();
    float fps = 1.f / currentTime;
    sf::Text tx;
    tx.setString(std::to_string((int)fps).c_str());
    tx.setPosition(600.0f,500.0f);
    tx.setFont(font);
    tx.setCharacterSize(16);
    wnd.draw(tx);
}

class Messages{
public:
    Messages(sf::Font& font)
        : font(font)
    {}

    void AddDummyMessage(){
        texts.push_back(sf::Text("This is a test message, because test.", font, 16));
        texts.back().setPosition(16, texts.size()*16);
    }

    sf::Font& font;
    std::vector<sf::Text> texts;
};

void DisplayMessages(const Messages& messages, sf::RenderTarget &wnd){
    // Using references here is very important to avoid useless copy of sf::Text
    for(auto& e : messages.texts){
        wnd.draw(e);
    }
}

int main()
{
    sf::RenderWindow wnd(sf::VideoMode(800,600,32), "Test");
    sf::Font font;
    font.loadFromFile("arial.ttf");
    sf::Clock clock;

    Messages messages(font);

    while(wnd.isOpen()){
        sf::Event evt;
        while(wnd.pollEvent(evt)){
            if(evt.type == sf::Event::KeyPressed && evt.key.code == sf::Keyboard::Space) {
                messages.AddDummyMessage();
            }
            else if (evt.type == sf::Event::Closed){
                wnd.close();
            }
        }

        wnd.clear();
        DisplayMessages(messages, wnd);
        DrawFps(wnd, clock, font);
        wnd.display();
    }
}
 

[val]

Thanks guys for the replies. Didn't know that creating objects on the fly would have *this* much impact on performance. Also thanks, Ixrec, on the #pragma-ing.