Taille d'un sf::Vertex

[Crone123]

Bonjour,
J'ai codé un moteur de particules en utilisant la SFML, et plus particulièrement avec des sf::Vertex et sf::Vertex Array.

Le moteur de particules a de très bonnes performances (je suis a env 300 - 350FPS avec 8000 particules, je tombe a 15FPS vers 400000 particules, donc y a de la marge)
Il gère le déplacement vectoriel, supporte des courbes, changement de couleur, etc....

J'aimerais lui rajouter la possibilité d'avoir des particules de différentes tailles. Actuellement les particules sont toutes de 1px.

Existe t-il un moyen de créer des particules plus grosse avec des sf::Vertex? (et sans détruire les perfs)
Je met tous mes sf::Vertex dans un gros sf::VertexArray et je fais un draw.
Comment pourrais-je faire pour augmenter la taille des particules? (si possible des particules "rondes")
Merci

[Laurent]

Il faut utiliser des sf::Quads au lieu de sf::Points, et pour avoir des particules rondes, il faut les texturer (le faire géometriquement va tuer tes performances).

[Crone123]

Si j'utilise des sf::Quads comme type de sf::VertexArray, je pourrais toujours mettre toutes les particules dedans puis faire un rendu, ou je dois faire un rendu pour chaque particule séparément?
ça risque d'être lourd si c'est séparé non?

sf::Quads, c'est pour un quadrilatère?
Comment j'utilise ça? Je met les 4 coins en sf::Vertex dedans?
Pour le texturer, j'utilise quoi?
Il n'existe pas un truc type "sf::Circle" pour les sf::VertexArray (bon, je demande, mais je ne l'ai pas vu ici donc je pense que non... )


Question tant que j'y suis: sf::VertexArray ne permet pas par hasard de générer des dégradé de barre de vie avec de meilleures perfs qu'un sf::RectangleShape ou sf::ConvexShape?
Merci

[Eroy]

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.

[Laurent]

Toutes les réponses à tes questions se trouvent dans le tutoriel sur les vertex arrays. L'as-tu lu ?

[Crone123]

Je n'avais pas vu ce tuto

sf::Circle, je ne l'ai pas vu dans le tuto non plus...

Pour ton code Eroy, je ne pourrais pas te dire si il fonctionne ou pas, je n'arrive pas a utiliser moi même OpenGL je verrais ça plus tard je pense (Note: J'ai que 16 ans, 17 dans 1mois.., je suis en 1SSI)

Par contre, j'ai lu le tuto des sf::VertexArray, et je dis chapeau Merci beaucoup pour ce tuto, je pensais pas qu'il était possible de faire des trucs aussi complets avec des sf::VertexArray
Je vais remplacer un bon nombre de sf::ConvexShape ou sf::RectangleShape par des sf::VertexArray, ça sera beaucoup plus performant, et je n'ai pas besoin de sf::ConvexShape, ou sf::RectangleShape, les textures sont des images gérées en C++ au lancement du jeu, avant j'utilisais des sf::Shape dans la version 1.6 pour faire un dégradé simplement. Je pense que je vais énormément augmenter les perfs de mon jeu grâce a ça


Pour les particules, je peux utiliser des sf::Quads pour avoir des particules carrées, ou bien des sf::Triangle pour des particules triangles, ou encore des triangleFan pour faire des imitations de cercles qui a mon sens seront tout aussi bien.
Reste a savoir si faire un draw de ces figures me permettra d'avoir des performances correctes.

Je vais essayer, on verra bien (Si vous savez déjà a l'avance ça m’intéresse aussi )
Merci

[Eroy]

De toute façon t'auras toujours la limite infranchissable qui t'empêchera d'utiliser des dizaines de milliers d'images, au font je ne pense pas qu'il y ai beaucoup de différences entre utiliser des sprites ou des shapes alors autant ne pas t'emmerder et utiliser des sprites... Après tests et tu verras bien.
Pour les particules il vaux mieux privilégier la qualité à la quantité : en utilisant des particules plus grosses, texturées et animées tu en auras besoin de beaucoup moins que pleins de petites et le résultat sera meilleur car dans tous les cas tu ne pourras jamais simuler de la fumée particule par particule (du moins pour une réelle utilisation et pas juste une demo).
Le plus intéressant dans les moteurs de particules basé cpu (et non pur gpu) c'est avant tout leurs gestions des déplacements et modifications et non leur performances.


Les particules c'est le truc que tu testeras le plus dans ta vie de programmeur... Juste parce que tu feras n'importe quoi avec pendant des heures sans te lasser.
https://fbcdn-sphotos-c-a.akamaihd.net/hphotos-ak-prn1/75019_515784541786989_321599495_n.png

[Crone123]

Je suis d'accord avec toi, les particules c'est de quoi s'occuper pendant des heures sans jamais s'ennuyer

Ton rendu est magnifique

C'est fait avec ton code?
Il faudrait vraiment que j'arrive a avoir des particules rondes
Je vais essayer de comprendre ton code

Voici un test que j'ai fait avec les différents types de particules que je viens de coder (pas encore fini complètement):
http://dl.smglive.org/FJ_1368142250.104_View
http://dl.smglive.org/FJ_1368142713.2688_View
http://dl.smglive.org/FJ_1368142760.6659_View
http://dl.smglive.org/FJ_1368143021.4441_View

OK, le mélange de couleur c'est un peu trop, mais effectivement, plus les particules sont grosses, et moins on a besoin d'en créer, et niveau perfs ça change tout
Je vais voir aussi pour rajouter une rotation des Triangles et des Quads
Le rendu des grosses particules (25px entre le centre et le coté) est super fluide

Mais vraiment, ton rendu est magnifique, les particules rondes, ça fait vraiment quelque chose


EDIT: Les Shape ont l'avantage d'être redimensionnable de la forme que je veux
Pour les barres de vie c'est le mieux, mais maintenant je les ferais avec des sf::VertexArray, c'est beaucoup mieux (j'ai pas besoin de générer de texture avant, je gagne de la ram, de la vitesse, et je me simplifie la vie )
Par contre, les Sprite c'est dégueulasse niveau perfs pour un moteur de particules XD

EDIT2: Dans ton code, quel est le type de its? Comment je défini la couleur des particules?
Merci

[Crone123]

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..

En tout cas, merci a vous deux pour votre aide, et merci d'avoir crée des trucs aussi puissant dans la SFML

[Eroy]

Non les sprites n'ont pas de perfs dégueulasses car de toute façon tu utilises une texture qui elle est déjà sur la carte graphique donc ça doit pas être tellement plus lourd que tes quads...

Sur mon image j'utilise une texture composé de plusieurs points ce qui permet de "multiplier" les particules. :3

[Laurent]

Vite fait car j'ai pas le temps d'en dire plus maintenant :

- les sprites c'est dégueu niveau perf pour les particules ; ce qui tue les performances c'est le nombre d'appels à draw, et entre 1 seul appel pour toutes tes particules, et 10000, franchement y a pas photo

- utilise des textures pour tes particules ! surtout pour les rondes ; ça ne coûtera pas beaucoup plus cher

- ton code est vraiment bizarre (des sf::Vertex alloués dynamiquement ?!), j'ai peur que tu ne fasses des choses très contre-productives

[Crone123]

Sur mon image j'utilise une texture composé de plusieurs points ce qui permet de "multiplier" les particules. :3

Une image contenant plusieurs particules?
Mais tu t'amuse a dessiner les particules sur GIMP ou bien tu met des points de base sur l'image qu'OpenGL dessine ensuite de la taille choisie?

- les sprites c'est dégueu niveau perf pour les particules ; ce qui tue les performances c'est le nombre d'appels à draw, et entre 1 seul appel pour toutes tes particules, et 10000, franchement y a pas photo

Oui, en fait il faudrait la possibilité de mettre des Array de Sprites comme des Vertex et ça résoudrait le problème

- utilise des textures pour tes particules ! surtout pour les rondes ; ça ne coûtera pas beaucoup plus cher

Comment rajouter des textures sur les particules?
Attention, la plupart des particules sont évolutives, donc leurs mettre une texture ne risque pas de tuer les performances?
Ceci dit, je peux créer un type de particule texturé juste pour ça, ça permettrait d'avoir un moteur complet selon ce qu'on veut faire

- ton code est vraiment bizarre (des sf::Vertex alloués dynamiquement ?!), j'ai peur que tu ne fasses des choses très contre-productives

Je ne pense pas :p
J'ai une classe (SMG::Gen_Part) contenant des SMG::Particule, le Gen_Part est le moteur en soit.
A l'utilisation, il suffit de rajouter des Particules dedans (pointeurs). Les particules contiennent en fait quelques variables de paramétrage de couleur, trajectoire, etc..
Le Gen_Part s'occupe de faire vivre les particules, les déplacer, les détruire, etc..c'est lui qui défini aussi la forme de toutes les particules. (On peut mettre plusieurs Gen_Part si on veut dessiner plusieurs formes différentes)

Les particules et les Vertex Alloués dynamiquement sont bien sûr supprimés après. (pas de fuite de mémoire)
L’intérêt est de me permettre de compter le nombre de particules présentes et les gérer plus simplement.
Enfin, ça doit pas être trop contre-performant étant donné les perfs que j'ai avec des points (Je suis sur une Nvidia GT 440 & I5 Quad Core a 3.2Ghz ou  Nvidia GT 220 & AMD Athlon II Dual Core a 2.7Ghz en fonction des fois, mais ça passe aussi bien sur l'un que l'autre )

[domoi]

Les particules et les Vertex Alloués dynamiquement sont bien sûr supprimés après. (pas de fuite de mémoire)
L’intérêt est de me permettre de compter le nombre de particules présentes et les gérer plus simplement.
Enfin, ça doit pas être trop contre-performant étant donné les perfs que j'ai avec des points  (Je suis sur une Nvidia GT 440 & I5 Quad Core a 3.2Ghz ou  Nvidia GT 220 & AMD Athlon II Dual Core a 2.7Ghz en fonction des fois, mais ça passe aussi bien sur l'un que l'autre  )

On évite le plus possible l'allocation de mémoire dynamique dans un jeux vidéo car ça affecte énormément les performances, en règle générale, on alloue toute la mémoire nécessaire au fonctionnement lors de l'initialisation du jeu.
Pour un système de particule, le pooling (http://en.wikipedia.org/wiki/Object_pool) se prête bien à ce système. Je fais cette remarque suite à la remarque de Laurent :

- ton code est vraiment bizarre (des sf::Vertex alloués dynamiquement ?!), j'ai peur que tu ne fasses des choses très contre-productives

[Eroy]

en règle générale, on alloue toute la mémoire nécessaire au fonctionnement lors de l'initialisation du jeu

Tu travail avec du matos d'il y a 20 ans ? 

[Crone123]

Perso j'alloue la mémoire nécessaire pour tout ce qui est textures/musiques, mais faut pas déconner, un jeu en réseau, des particules ou autres, c'est imprévisible, je vais pas m'amuser a allouer la masse de mémoire inutilement pour le cas où y ait des particules en plus.

Sinon, pour ma question de justement comment mettre une texture sur un sf::Quads, qu'un a une réponse?
Merci

EDIT: J'ai trouvé, c'est dans le tuto, et ça fonctionne, merci