Geometry Shader et Wide Line

Bonjour à tous,
Je cherche un tutoriel ou un exemple, qui montre comment obtenir des ligne épaisses à partir de simple ligne avec DirectX 10 et HLSL
J'ai beau tout essayé je trouve rien :(

J'ai bien lu l'exemple de Nvidia -Solid Wire Frame (http://developer.download.nvidia.com...d/samples.html ) mais ca correspond pas à ce que je veux car j'ai des lignes et dans leur exemple, ils calculent le rapprochement des bords d'un triangle ...

J'ai aussi trouvé le site de microsoft qui fait référence au Wide Line Tesseliation mais c'est pas exactement ce que je cherche ... Bref, si quelqu'un a un tuto sous la main, un exemple, ou alors pourrait m'indiquer les mots clés a chercher, merci d'avance !

bonjour,

je dirai que ce n'est pas très compliqué.

ce qu'il manque pour donner de l'épaisseur à une ligne (2 vertices) c'est de l'afficher avec 2 triangles (4 vertices).
on en revient avec la même technique pour la génération de quad pour l'affichage de particules.

donc dans ton geometry shader il faut déterminer un vecteur perpendiculaire à ta ligne qui se trouve aussi dans un plan ayant pour normal la direction de ta caméra; ce vecteur P te permettra de donner de l'épaisseur à ta ligne.

calculer les 4 coins de ton quad à peut près de cette manière :
soit V0 et V1 les vertices de ta ligne.

Code:

---

1 2 3 4 5

float3 T = 0.5 * épaisseur * P; float3 v0 = V0 + T; float3 v1 = V0 - T; float3 v2 = V1 + T; float3 v3 = V1 - T;

---

il ne restera plus qu'à envoyé v0, v1, v2 et v3 dans le stream de sortie du GS.

Hum... C'est a peu pret la méthode que j'utilisais avant ... Mes problèmes d'affichages doivent pas venir de la alors !

Petite question, quelle intérêt de le faire dans le GeometryShader, plutôt que de calculer ça avant de tout envoyer dans le pipeline ?

Merci,

mettons que, par exemple, tu as 2 millions de lignes distinctes les unes des autres, donc 4 millions de vertices, 2 vertices par ligne.

d'un coté tu traites ça sur le gpu :
- tu envoies sur le pipeline 4 millions de vertices, les 8 millions nécessaires sont générés sur le gpu.

si tu fais ça du coté cpu :
- tu as tes 2 millions de lignes, il faut que tu génères les 8 millions de vertices sur le cpu, donc que tu les stockes et ensuite les envoies sur le pipeline.

résumons :

méthode gpu :
- espace de stockage pour 2 millions de lignes donc 4 millions de vertices
- transfert de 4 millions de vertices au gpu

méthode cpu :
- espace de stockage pour 2 millions de lignes donc 4 millions de vertices
- espace de stockage pour les 8 millions de vertices pour les quads complets
- transfert de 8 millions de vertices au gpu

il est vrai que mon calcul est peut être un peu excessif, mais donne une petite idée des conséquences de choisir l'une ou l'autre méthode.

Bah au final le calcul n'est pas si excessif que ça ...

En gros donc y vaut mieux que je split les calculs entre CPU et GPU quand c'est possible ?

Mais d'un autre côté ...
Actuellement le calcul pour les 4 vertices par ligne se fait a l'instanciation de ma courbe, donc je le fais qu'une fois. De cette manière c'est peut être mieux de faire le calcul par le CPU non ?
Dans un second temps je pense que le calcul se fera effectivement dans la boucle d'affichage, et ca serait plus efficace de le faire dans le GPU

C'est correct comme reflexion ?
Si le calcul ne doit se faire qu'une fois -> CPU
Si le calcul doit se faire à chaque affichage -> GPU

C'est une habitude que je devrais prendre ?

En gros donc y vaut mieux que je split les calculs entre CPU et GPU quand c'est possible ?

oui et non, comme tu le dis après c'est selon la fréquence de mise à jour de tes données.

par contre il ne faut pas que tu oublies que tu dois faire le calcul pour mettre le quad résultant face à ta caméra, donc dans ton cas, je ne pense pas que ça soit cohérent de faire une partie des calculs sur le cpu.

surtout que si tu fais comme ça, il te faut un moyen de savoir sur le gpu à quelle ligne appartient le triangle que tu orientes pour justement l'orienter correctement car ta caméra à toute les chances de changer à chaque frame.