如何用颜色填充 sf::TriangleStrip 的 sf::VertexArray？

Question

I would like to increase the drawing performance by using a single sf::VertexArray to display thousands of circles. To make sure it works, I wrote this example:

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

#define WIDTH 100
#define HEIGHT 100

int main() {
    sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "RTREE",
                            sf::Style::Close);
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) window.close();
        }

        sf::CircleShape circle(50);
        circle.setPosition(100,100);
        size_t count = circle.getPointCount();
        sf::VertexArray objects(sf::TriangleStrip, count);
        for (int i = 0; i < count; i++) {
           objects.append(circle.getPoint(i));

        }
        for (int i = 0; i < objects.getVertexCount(); i++) {
            objects[i].color = sf::Color::Blue;
        }

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

However, the color only applies to the line, not the fill:

Is it possible to fill the shape with a single color?

Answer 1

You are right, displaying more than 1000 circles with a window.draw between each of them result in poor performances. The vertexArray is indeed a good solution.

You used sf::TriangleStrip which does not work as you expected. Your verticles are indeed painted, but they are only on the edge of the circle. You need to use either sf::TriangleFan or sf::Triangles if you want more than one circle per array.

Here an example. I was able to display 513'000 verticles at 60 fps (each circle is about 30 verticles, which is about 10'000 circles.

#include <SFML/Graphics.hpp>
#include <cmath>
#include <iostream>
#include <sstream>
#define WIDTH 800
#define HEIGHT 800
using namespace std;

template <typename T>
std::string to_string_with_precision(const T a_value, const int n = 6)
{
    std::ostringstream out;
    out.precision(n);
    out << std::fixed << a_value;
    return out.str();
}

void addCircle(sf::VertexArray &array, sf::Vector2f position, float radius, sf::Color color) {
    size_t count = 30;

    for (int i = 0; i < count; i += 1) {
        sf::Vertex v0;
        v0.position = sf::Vector2f(position.x, position.y);
        v0.color = color;
        array.append(v0);

        sf::Vertex v1;
        float angle = i * 2 * M_PI / count;
        v1.position = sf::Vector2f(position.x + cos(angle) * radius, position.y + sin(angle) * radius);
        v1.color = color;
        array.append(v1);

        sf::Vertex v2;
        angle = (i + 1) * 2 * M_PI / count;
        v2.position = sf::Vector2f(position.x + cos(angle) * radius, position.y + sin(angle) * radius);
        v2.color = color;
        array.append(v2);
    }
}

#define FRAMERATE 120

int main() {
    sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "RTREE", sf::Style::Close);

    // Fps text
    sf::Font font;
    if (!font.loadFromFile("../assets/collegiate.ttf")) {
        std::cout << "Error loading font" << std::endl;
    }
    sf::Text fps;
    fps.setFont(font);
    fps.setPosition(10, 10);
    fps.setCharacterSize(16);
    fps.setFillColor(sf::Color::White);

    // Time management
    sf::Clock clock;
    sf::Time timeSinceLastUpdate = sf::Time::Zero;
    sf::Time timePerFrame = sf::seconds(1.f / FRAMERATE);
    sf::Time timeSinceLastDraw = sf::Time::Zero;
    window.setFramerateLimit(FRAMERATE);

    float vr = 0;

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

        size_t count = 15;
        sf::Color color = sf::Color::Red;
        color.a = 50;
        sf::Color color2 = sf::Color::Blue;
        color2.a = 20;

        sf::VertexArray objects(sf::Triangles);

        for (int k = 0; k < 5; k++) {
            sf::Color c = k % 2 ? color : color2;

            for (int j = 20; j < 400; j += 5) {
                for (int i = 0; i < count; i++) {
                    float angle = i * 2 * M_PI / count;
                    angle += (i % 2 ? vr : -vr) * k * (k % 2 ? 1 : -1);
                    addCircle(objects, sf::Vector2f(WIDTH / 2 + cos(angle) * j, HEIGHT / 2 + sin(angle) * j), j / 5, c);
                }
            }
        }


        timeSinceLastDraw = clock.restart();
        timeSinceLastUpdate += timeSinceLastDraw;
        double timeFps = 1.f / timeSinceLastDraw.asSeconds();
        fps.setString("verticles: " + to_string_with_precision(objects.getVertexCount(), 0) + " fps: " + to_string_with_precision(timeFps, 0));

        while (timeSinceLastUpdate > timePerFrame) {
            timeSinceLastUpdate -= timePerFrame;
            vr += 0.01;
        }

        window.clear();
        window.draw(objects);
        window.draw(fps);
        window.display();
    }
}