Drawing large triangles/sprites is slow | Possible bug?

[Paschka]

Hello,

drawing large triangles or sprites seems to be unreasonably slow for me. My minimum test case draws 10 triangles with a size of 800x800 at 200 FPS. However, I can draw about 500 triangles with a size of 100x100 before I get down to roughly the same frame rate.

My specs:
Intel Core i5-5200U 2.2 GHz
Intel HD Graphics 5500
4 GB RAM
Ubuntu 16.10

Testcase below. I omitted "displayFPS()" for readability.

(click to show/hide)

#include <SFML/Graphics.hpp>

sf::RenderWindow window(sf::VideoMode(1200,800,32), "Test");


sf::VertexArray createTriangle(sf::Color color, sf::Vector2f pos, float size) {
        sf::VertexArray array(sf::Triangles, 3);
        array[0].position = pos;
        array[0].color = color;
        array[1].position = sf::Vector2f(pos.x + size, pos.y);
        array[1].color = sf::Color(0,0,0,0);
        array[2].position = sf::Vector2f(pos.x + size, pos.y+size);
        array[2].color = sf::Color(0,0,0,0);

        return array;
}

int main(int argc, char *argv[]) {
   
    // Create triangles
        int count = 10;
        sf::VertexArray vertices[count];
        for (int i = 0; i < count; i++) {
            // Use random color and random position
                sf::Color randColor = sf::Color(rand()%255, rand()%255, rand()%255, rand()%255);
                sf::Vector2f randPos(rand() % 600, rand() % 400);
                vertices[i] = createTriangle(randColor, randPos, 800);
        }
       
        sf::Clock clock;
        while (window.isOpen()) {
            // Display FPS
                float dt = clock.getElapsedTime().asMilliseconds();
                displayFps(dt);
                clock.restart();
                window.clear();
               
                // Draw triangles
                for (int i = 0; i < count; i++) {
                        window.draw(vertices[i]);
                }
                window.display();
       
        // Poll events
                while (window.pollEvent(event)) {
                        if (event.type == sf::Event::Closed) {
                                window.close();
                        }
                }
        }
}

Edit: Renamed "circlecount" to "count"

[eXpl0it3r]

Intel GPUs are known to not be very performant compared to dedicated GPUs.
Wgat driver are you using?

As for the code, you're totally missing the point of a vertex array. They exist to batch draw primitives and not to draw single triangles.

And finally 200 FPS is still quite high. Remember that FPS is non-linear, this means that the FPS will not go down proportionally to the number of drawn triangles.

[Paschka]

Intel GPUs are known to not be very performant compared to dedicated GPUs.
Wgat driver are you using?

I used the Intel Graphics Installer to get (presumably) the right one.

As for the code, you're totally missing the point of a vertex array. They exist to batch draw primitives and not to draw single triangles.

Yes, but isn't the point of vertex arrays to reduce the number of draw calls? I merely used 10 for the large triangles. Drawing these 10 triangles at once wouldn't really make a difference, would it?

And finally 200 FPS is still quite high. Remember that FPS is non-linear, this means that the FPS will not go down proportionally to the number of drawn triangles.

I didn't know about the non-linearity, thank you. But still, I'm not complaining about the overall loss of FPS.
Running the same test with 100 large triangles and then with 5000 small triangles both results in about 30 FPS.
Grouped together in a large vertex array, I can use 200 large triangles or 10000 small triangles to get the same result.

I'm rather complaining about the relative loss since I could draw 50 times more triangles when they were smaller.
Is this normal behaviour? Does that mean that I have to split large triangles into smaller ones?

[eXpl0it3r]

Yes, but isn't the point of vertex arrays to reduce the number of draw calls? I merely used 10 for the large triangles. Drawing these 10 triangles at once wouldn't really make a difference, would it?

The point of vertex arrays is to reduce draw calls and since draw calls are relatively slow/expensive batching vertices together can perform better. However there shouldn't be that big of a difference for 10 draw calls.

I'm rather complaining about the relative loss since I could draw 50 times more triangles when they were smaller.
Is this normal behaviour? Does that mean that I have to split large triangles into smaller ones?

There are different computations to be done, so it can very well yield different results, but generally even a Intel GPU should be able to handle a good amount of draw calls.

So if you run some other simple OpenGL games, do they run fine? What driver version did that installer install exactly? If you get some OpenGL testing tool, what OpenGL version does it say is supported and what else does it report?

Do you see a lot of difference if you run it in release mode? Might want to get a profiler and figure out where the bottleneck is.

[Paschka]

So if you run some other simple OpenGL games, do they run fine?

Well, my  Intel GPU is indeed a little slow but Trine runs in windowed mode with 1280x800 at around 20 FPS.

What driver version did that installer install exactly?

i915 4.4.0-53-generic

If you get some OpenGL testing tool, what OpenGL version does it say is supported and what else does it report?

glmark2 runs in "OpenGL 3.0 Mesa 13.1.0-devel". A quick look in glxinfo confirms this (there is no version 4.*).
Besides, my glmark2 score is 526 and most glmark2 tests run at 200-500 FPS.

Do you see a lot of difference if you run it in release mode?

Nope. No difference with fullscreen and deactivated V-Sync either.

Might want to get a profiler and figure out where the bottleneck is.

Any suggestions what to use or how to do that?

[Chaia*]

Maybe you are just Fillrate-limited.

Number of pixels your graphics card has to draw:
With 10 large triangles: 10x800x800/2 = 3.2 Megapixel
With 500 small triangles: 500x100x100/2 = 2.5 Megapixel

So actually in terms of fillrate, 500 of your small triangles are even faster than 10 of your large ones. But with 500 triangles you get more overhead (draw calls) and more load on the rasterizer etc. In the end you get about the same performance.

I don't know if this is the reason for your observed behaviour but for me it seems plausible.

[DarkRoku12]

Maybe you are just Fillrate-limited.

Number of pixels your graphics card has to draw:
With 10 large triangles: 10x800x800/2 = 3.2 Megapixel
With 500 small triangles: 500x100x100/2 = 2.5 Megapixel

So actually in terms of fillrate, 500 of your small triangles are even faster than 10 of your large ones. But with 500 triangles you get more overhead (draw calls) and more load on the rasterizer etc. In the end you get about the same performance.

I don't know if this is the reason for your observed behaviour but for me it seems plausible.

I couldn't have said it better.

[Paschka]

Maybe you are just Fillrate-limited.

Number of pixels your graphics card has to draw:
With 10 large triangles: 10x800x800/2 = 3.2 Megapixel
With 500 small triangles: 500x100x100/2 = 2.5 Megapixel

So actually in terms of fillrate, 500 of your small triangles are even faster than 10 of your large ones. But with 500 triangles you get more overhead (draw calls) and more load on the rasterizer etc. In the end you get about the same performance.

I don't know if this is the reason for your observed behaviour but for me it seems plausible.

Then there wouldn't be much I could do, I guess. Thanks, anyway.