Les sf::Circle sont des lignes droites tracée en cercle, c'est pour ça que tu peux en choisir le nombre de points.
Il est possible de texturer un point, voilà un code qui me permet d'afficher des particules en utilisant des points :
(Je peux pas te dire par contre si c'est plus performant d'utiliser des points plutôt que des quads ou même si ce code ne génère tout simplement pas des quads.)
#include <GL/gl.h>
#include <GL/glext.h>
glEnable(GL_POINT_SPRITE_NV);
glPointSize(size);
glVertexPointer(2, GL_FLOAT, 0, positionsXY.data()); // positionsXY -> {x1, y1, x2, y2, ...}
for (unsigned int i = 0; i < its.size(); i += 2)
{
glDrawArrays(GL_POINTS, its[i], its[i+1]-its[i]);
}
glDisable(GL_POINT_SPRITE_NV);
Tu peux y ajouter une texture à l'aide d'une shader.
Par contre personnellement j'ai laissé tombé... j'avais pourtant réussi à le linker avec de l'opencl qui calculait les positions des particules etc... Le soucis c'est les perfs de l'affichage des particules en soit, afficher 8000 particules c'est bien mais faut pas oublier que derrière tu vas faire tourner un jeu qui lui-même demandera de dessiner (et se sera même plus lourd). Donc bon... J'aimerais bien réussir le link opencl->texture pour avoir de réelles particules en masse mais franchement j'y arrive pas... (de toute façon rien que l'opencl c'est déjà une chiure pas possible).
Donc voilà bonne chance mais jte conseil de pas trop rêver sur le nombre de particules que tu pourras gérer avec sfml (enfin là en l'occurrence je devrais dire avec opengl) par des techniques standards si tu veux pas être déçu.
En fait, j'ai réussi a faire des cercles avec la SFML:
case CIRCLE:
static float Angle(0), AngleAdd(0);
if(Pointeur->Vertices <= 0)
{
Pointeur->Vertices = 1;
}
Angle = 0;
AngleAdd = float(M_PI) / float(Pointeur->Vertices);
for(unsigned int C2(0);C2 < Pointeur->Vertices;++C2)
{
PV = new sf::Vertex(sf::Vector2f(Pointeur->Position.x + (cos(Angle) * Pointeur->Taille), Pointeur->Position.y + (sin(Angle) * Pointeur->Taille)), sf::Color(Pointeur->CR, Pointeur->CG, Pointeur->CB, Pointeur->CA));
PT.append(*PV);
AP.push_back(PV);
PV = new sf::Vertex(sf::Vector2f(Pointeur->Position.x + (cos(Angle + M_PI) * Pointeur->Taille), Pointeur->Position.y + (sin(Angle + M_PI) * Pointeur->Taille)), sf::Color(Pointeur->CR, Pointeur->CG, Pointeur->CB, Pointeur->CA));
PT.append(*PV);
AP.push_back(PV);
Angle += AngleAdd;
}
break;
Mon moteur de particules gère maintenant tous les types de sf::VertexArray, on peut faire des rendus vraiment variés :)
Pour les cercles par contre, c'est le type de particule qui bouffe le plus de processeur.
Si bien utilisé (pas trop de vertices), c'est fluide, mais si on commence a trop en mettre, y a intérêt a pas lancer 5000 particules d'un coup sinon les perfs ont quelques problèmes.
Par contre, des particules de taille inférieure a 5 avec quelques vertices donnent un visuel de cercle, et sans impacter les performances.
En mettant moins de vertice (et donc en améliorant les perfs), on peut donner des effets de flocon de neige, etc.. :D
En tout cas, merci a vous deux pour votre aide, et merci d'avoir crée des trucs aussi puissant dans la SFML :D