Get rid of the state cache inside RenderTarget

[eXpl0it3r]

SFML master: ~1100 FPS
useVertexCache = false: ~450 FPS

Anything else to test?

[Tank]

With caching: ~57 FPS
Without caching: ~59 FPS

I have *no* idea why it's so damn slow in both cases, but at least there's a slight effect.

02:00.0 VGA compatible controller: NVIDIA Corporation GK104 [GeForce GTX 660 Ti] (rev a1)

[SpeCter]

With caching: ~57 FPS
Without caching: ~59 FPS

I have *no* idea why it's so damn slow in both cases, but at least there's a slight effect.

02:00.0 VGA compatible controller: NVIDIA Corporation GK104 [GeForce GTX 660 Ti] (rev a1)

Driver enabled vsync maybe?
I think in this case the 2 fps difference is more likely just noise and not something which comes from caching/non-caching.

[Tank]

Driver enabled vsync maybe?

Nope, it's not vsync. With 1024 sprites I get ~147.

I think in this case the 2 fps difference is more likely just noise and not something which comes from caching/non-caching.

I don't think so, as I've watched the numbers for like a minute. It's reproducible as well.

[Nexus]

SFML master: ~186 FPS
Disabled vertex cache: ~75 FPS

Intel HD Graphics 3000
(I had to use a small image or the framerate was abysmal)

By the way, the code needs a #include <numeric> for std::accumulate(). It should allocate the sprites dynamically; I got a stack overflow.

[Mario]

Which texture are you guys using? These values don't sound right to me. I've used the OpenGL example's "texture.png":

Unmodified master branch: ~81 FPS
Vertex cache disabled: ~92 FPS

Geforce GTX 680 in a x64 release build of SFML.

Updated code:

(click to show/hide)

Code: [Select]

#include <SFML/Graphics.hpp>
#include <algorithm>
#include <sstream>
#include <numeric>

int main()
{
    sf::RenderWindow window(sf::VideoMode(800, 600, 32), "Test");
    window.setVerticalSyncEnabled(false);

    sf::Clock clock;
    sf::Event event;
    std::stringstream sstr;

    sf::Texture texture;
    if (!texture.loadFromFile("resources/texture.jpg"))
        return EXIT_FAILURE;

    sf::Sprite *sprites = new sf::Sprite[4096];

    for (int i = 0; i < 4096; i++)
        sprites[i].setTexture(texture);

    float deltas[256];
    int index = 0;

    while (window.isOpen())
    {
        deltas[index = ((index + 1) % 256)] = clock.restart().asSeconds();

        if (!index)
        {
            float avg = std::accumulate(deltas, deltas + 256, 0.f) / 256.f;
            sstr.str("");
            sstr << "Frame Time: " << avg << "s -- " << (1.f / avg) << " FPS";
            window.setTitle(sstr.str());
        }

        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                return EXIT_SUCCESS;
        }

        window.clear();

        for (int i = 0; i < 4096; i++)
            window.draw(sprites[i]);

        window.display();
    }

    delete [] sprites;
}


[Tank]

Mario: Used the same.

[hobby]

Updated code:
...

GeForce GT610 2GB.
Using above code on master of 3 weeks ago, OpenGL example texture.jpg, x32 Release:
- With & without vertex cache ~ 4.6 FPS

I suspected that there's no difference due to fillrate limitation vs. low # of OpenGL calls, so I reduced texture size to 64x64:

sprites[i].setTextureRect(sf::IntRect(0, 0, 256/4, 256/4));

Results:
- With vertex cache - 140 FPS
- Without vertex cache - 83.5

Those of you that got negligible difference, could you re-run your tests with smaller texture sizes?