Bonjour,

Actuellement j'utilise Poly2Tri et LibTessDotNet pour triangulariser des polygones quelconques avec des trous, issu de calculs faits avec Clipper.

Je cherche à utiliser ou à trouver un portage en VB.NET ou en C# de la fonction tessellation OpenGL (GLUtessellator) complète

Je m'explique...

LibTessDotNet serait un portage de la méthode de GLUtessellator, mais elle ne peut générer en sortie qu'une liste de triangles

Or, dans la fonction GLUtessellator, il y a cette fonctionnalité intéressante :

OpenGL tessellator decides the most efficient primitive type while performing tessellation; GL_TRIANGLE, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP and GL_LINE_LOOP.
http://www.songho.ca/opengl/gl_tessellation.html

Ce que je voudrais faire, c'est utiliser (ou trouver un portage) de cette fonction pour récupérer, en sortie, un mélange de GL_TRIANGLE, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP.

En effet, les GL_TRIANGLE_FAN et GL_TRIANGLE_STRIP sont bien plus économes en mémoire, tout en étant aussi rapides que les triangles indexés.

J'ai besoin de récupérer en sortie les données GL_TRIANGLE, GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP pour les stoker en mémoire pour :
- faire la tessellation d'un polygone une seule fois
- pouvoir travailler avec les données

J'ai passé pas mal de temps à chercher sur Internet, mais
- soit je trouve des fonctions de tessellation qui ne donnent que des triangles en vrac ou indexés
- soit comment utiliser GLUtessellator pour de l'affichage via des callbacks

En fait, dans mon programme, il faut considérer la performance de l'ensemble de la chaîne de fonctions qui réalise la triangularisation, le stockage et l'affichage.

Du coup la méthode de triangularisation Poly2Tri qui est réputée est pénalisante car elle ne donne en sortie que des triangles non indexés ; dans de rares cas Poly2Tri échoue il faut une méthode de secours (dans mon cas LibTess)

La méthode de LibTessDotNet est robuste mais les triangles sont de moins bonne qualité (trop pointus par rapport à Poly2Tri, ça donne du fil à retordre au logiciels CAO) ; LibTessDotNet donne en sortie des triangles indexés ce qui permet un usage optimal avec un OpenGL moderne. Mais il reste la consommation mémoire...

Car pour des polygones en 2.5D (en 3D mais parallèle au plan XY) avec des GL_TRIANGLE_FAN et GL_TRIANGLE_STRIP je consomme :
- 2,5 fois moins de mémoire qu'avec des triangles indexés
- 3 fois moins de mémoire qu'avec des triangles non indexés

En 2.5D on a seulement besoin des coordonnées X et Y des points ; on ne stocke par la normale pour chaque triangle car il y a une normale unique pour le polygone Z=1 ou Z=-1
Les coordonnées X et Y se stockent sur 4 octets chacune (type Single)
Les index sont des entiers sur 32 bits donc se stockent sur 4 octets (un entier sur 2 octets n'offre qu'une valeur maxi de 65535 ce qui est trop faible)
Prenons un polygone triangulé en 'n' triangles :
- sous forme de GL_TRIANGLE_FAN ou GL_TRIANGLE_STRIP il coute (n+2) points en stockage, donc (n+2) * 8 octets
- sous forme de triangles indexés il faut stocker n points mais en plus il faut stocker 3 index par triangle donc n * 20 octets
- sous forme de triangles non indexés il faut stocker 3 * n points donc n * 24 octets

NB : un polygone triangularisé de 'n' sommets compte environ 'n' triangles

NB : en 3D "pure" la différence s'estompe, à cause du stockage des normales à faire pour chaque triangle
- GL_TRIANGLE_FAN ou GL_TRIANGLE_STRIP : un point X,Y,Z + une normale NX,NY,NZ par triangle => (n+2) * 24 octets
- Triangles indexés il faut stocker un point X,Y,Z + une normale NX,NY,NZ + 3 index par triangle n * 36 octets (gain 30% "seulement")
- sous forme de triangles non indexés il faut stocker 3 points X,Y,Z + une normale NX,NY,NZ par triangle donc n * 48 octets (gain 50% "seulement")

Même en 3D GL_TRIANGLE_FAN ou GL_TRIANGLE_STRIP restent avantageux en occupation mémoire - 50% ou 30% de RAM consommée en moins je ne crache pas dessus !
J'arrive à avoir de très grosses pièces 3D qui mettent le PC à l'épreuve, avec plusieurs Go de RAM utilisé

S'agissant de la vitesse d'affichage, il n'y a pas d'intérêt :
- avec du vieux code utilisant des triangles non indexés et du vieux matériel (goulet d'étranglement RAM -> GPU) on gagne, mais ça reste un cas particulier
- avec du vieux code utilisant des triangles non indexés et du matériel récent on gagne un peu
- avec du code moderne il n'y a pas de gain, ça peut même être plus lent (logique car tout ayant été fait au niveau du hardware et des pilotes pour optimiser au maximum les triangles indexés)

A bientôt

Merci