Share via

Fonction gluTessCallback

  • Article

La fonction gluTessCallback définit un rappel pour un objet tessellation.

Syntaxe

void WINAPI gluTessCallback(
   GLUtesselator *tess,
   GLenum        which,
   void (CALLBACK *fn)()
);

Paramètres

Tess

Objet tessellation (créé avec gluNewTess).

Qui

Rappel en cours de définition. Les valeurs suivantes sont valides : GLU_TESS_BEGIN, GLU_TESS_BEGIN_DATA, GLU_TESS_EDGE_FLAG, GLU_TESS_EDGE_FLAG_DATA, GLU_TESS_VERTEX, GLU_TESS_VERTEX_DATA, GLU_TESS_END, GLU_TESS_END_DATA, GLU_TESS_COMBINE, GLU_TESS_COMBINE_DATA, GLU_TESS_ERROR et GLU_TESS_ERROR_DATA.

Pour plus d’informations sur ces rappels, consultez la section Remarques suivante.

Fn

Fonction à appeler.

Valeur renvoyée

Cette fonction ne retourne pas de valeur.

Notes

Utilisez gluTessCallback pour spécifier un rappel à utiliser par un objet de pavage. Si le rappel spécifié est déjà défini, il est remplacé. Si fn a la valeur NULL, le rappel existant devient non défini.

L’objet tessellation utilise ces rappels pour décrire comment un polygone que vous spécifiez est divisé en triangles.

Il existe deux versions de chaque rappel: une avec des données polygones que vous pouvez définir et une autre sans. Si les deux versions d’un rappel particulier sont spécifiées, le rappel avec les données polygonales que vous spécifiez sera utilisé. Le paramètre polygon_data de gluTessBeginPolygon est une copie du pointeur spécifié lors de l’appel de gluTessBeginPolygon .

Voici les rappels valides :

Rappel Description
GLU_TESS_BEGIN Le rappel GLU_TESS_BEGIN est appelé comme glBegin pour indiquer le début d’une primitive (triangle). La fonction prend un argument unique de type GLenum. Si vous définissez la propriété GLU_TESS_BOUNDARY_ONLY sur GL_FALSE, l’argument est défini sur GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP ou GL_TRIANGLES. Si vous définissez la propriété GLU_TESS_BOUNDARY_ONLY sur GL_TRUE, l’argument a la valeur GL_LINE_LOOP. Le prototype de fonction pour ce rappel est le suivant : voidbegin (typeGLenum) ;
GLU_TESS_BEGIN_DATA GLU_TESS_BEGIN_DATA est identique au rappel GLU_TESS_BEGIN, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voidbeginData (typeGLenum, void * polygon_data) ;
GLU_TESS_EDGE_FLAG Le rappel GLU_TESS_EDGE_FLAG est similaire à glEdgeFlag. La fonction prend un seul indicateur booléen qui indique les arêtes qui se trouvent sur la limite du polygone. Si l’indicateur est GL_TRUE, chaque sommet qui suit commence un bord qui se trouve sur la limite du polygone ; c’est-à-dire un bord qui sépare une région intérieure d’une région extérieure. Si l’indicateur est GL_FALSE, chaque sommet qui suit commence un bord qui se trouve à l’intérieur du polygone. Le rappel GLU_TESS_EDGE_FLAG (s’il est défini) est appelé avant le premier rappel de vertex. Étant donné que les ventilateurs triangle et les bandes de triangle ne prennent pas en charge les indicateurs de bord, le rappel de début n’est pas appelé avec GL_TRIANGLE_FAN ou GL_TRIANGLE_STRIP si un rappel d’indicateur de bord est fourni. Au lieu de cela, les ventilateurs et les bandes sont convertis en triangles indépendants. Le prototype de fonction pour ce rappel est :
voidedgeFlag (indicateur GLboolean);
GLU_TESS_EDGE_FLAG_DATA Le rappel GLU_TESS_EDGE_FLAG_DATA est le même que le rappel GLU_TESS_EDGE_FLAG, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voidedgeFlagData (indicateur GLboolean, void * polygon_data) ;
GLU_TESS_VERTEX Le rappel GLU_TESS_VERTEX est appelé entre les rappels de début et de fin. Il est similaire à glVertex et il définit les sommets des triangles créés par le processus de pavage. La fonction prend un pointeur comme seul argument. Ce pointeur est identique au pointeur opaque que vous avez fourni lorsque vous avez défini le sommet (voir gluTessVertex). Le prototype de fonction pour ce rappel est : vertex void (void * vertex_data) ;
GLU_TESS_VERTEX_DATA Le GLU_TESS_VERTEX_DATA est identique au rappel GLU_TESS_VERTEX, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voidvertexData (void * vertex_data, void * polygon_data) ;
GLU_TESS_END Le rappel GLU_TESS_END sert le même objectif que glEnd. Elle indique la fin d’une primitive et ne prend aucun argument. Le prototype de fonction pour ce rappel est : voidend (void) ;
GLU_TESS_END_DATA Le rappel GLU_TESS_END_DATA est identique au rappel GLU_TESS_END, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voidendData (void * polygon_data) ;
GLU_TESS_COMBINE Appelez le rappel GLU_TESS_COMBINE pour créer un sommet lorsque la jonction détecte une intersection ou pour fusionner des fonctionnalités. La fonction prend quatre arguments : tableau de trois éléments, chacun de type Gldouble.
Tableau de quatre pointeurs.
Tableau de quatre éléments, chacun de type GLfloat.
Pointeur vers un pointeur.
Le prototype de fonction pour ce rappel est :
voidcombine(GLdoublecoords[3], void * vertex_data[4], poids GLfloat[4], void **outData);
Le sommet est défini comme une combinaison linéaire de jusqu’à quatre sommets existants, stockés dans vertex_data. Les coefficients de la combinaison linéaire sont donnés par poids ; ces pondérations sont toujours égales à 1.0. Tous les pointeurs de vertex sont valides même si certains poids sont nuls. Le paramètre coords donne l’emplacement du nouveau sommet.
Allouez un autre sommet, interpolez les paramètres à l’aide de vertex_data et de poids, puis retournez le nouveau pointeur de vertex dans outData. Ce handle est fourni lors du rendu des rappels. Libérez la mémoire après l’appel de gluTessEndPolygon.
Par exemple, si le polygone se trouve dans un plan arbitraire dans un espace tridimensionnel et que vous associez une couleur à chaque sommet, le rappel GLU_TESS_COMBINE peut ressembler à ce qui suit :
void myCombine( GLdouble coords[3], VERTEX *d[4],                 GLfloat w[4], VERTEX **dataOut ) {     VERTEX *newVertex = new_vertex();     newVertex->x = coords[0];     newVertex->y = coords[1];     newVertex->z = coords[2];     newVertex->r = w[0]*d[0]->r + w[1]*d[1]->r + w[2]*d[2]->r +                    w[3]*d[3]->r;     newVertex->g = w[0]*d[0]->g + w[1]*d[1]->g + w[2]*d[2]->g +                    w[3]*d[3]->g;     newVertex->b = w[0]*d[0]->b + w[1]*d[1]->b + w[2]*d[2]->b +                    w[3]*d[3]->b;     newVertex->a = w[0]*d[0]->a + w[1]*d[1]->a + w[2]*d[2]->a +                    w[3]*d[3]->a;     *dataOut = newVertex; }
Lorsque la liaison détecte une intersection, le rappel GLU_TESS_COMBINE ou GLU_TESS_COMBINE_DATA (voir ci-dessous) doit être défini et doit écrire un pointeur non NULL dans dataOut. Sinon, l’erreur GLU_TESS_NEED_COMBINE_CALLBACK se produit et aucune sortie n’est générée. (Il s’agit de la seule erreur qui peut se produire pendant le pavage et le rendu.)
GLU_TESS_COMBINE_DATA Le rappel GLU_TESS_COMBINE_DATA est identique au rappel GLU_TESS_COMBINE, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voidcombineData (GLdoublecoords[3], void *vertex_data[4], GLfloatweight[4], void **outData, void * polygon_data) ;
GLU_TESS_ERROR Le rappel GLU_TESS_ERROR est appelé lorsqu’une erreur est rencontrée. Le seul argument est de type GLenum ; il indique l’erreur spécifique qui s’est produite et est défini sur l’un des éléments suivants : GLU_TESS_MISSING_BEGIN_POLYGON
GLU_TESS_MISSING_END_POLYGON
GLU_TESS_MISSING_BEGIN_CONTOUR
GLU_TESS_MISSING_END_CONTOUR
GLU_TESS_COORD_TOO_LARGE
GLU_TESS_NEED_COMBINE_CALLBACK
Appelez gluErrorString pour récupérer les chaînes de caractères décrivant ces erreurs. Le prototype de fonction pour ce rappel est le suivant :
erreur void (GLenumerrno) ;
La bibliothèque GLU récupère les quatre premières erreurs en insérant le ou les appels manquants. GLU_TESS_COORD_TOO_LARGE indique que certaines coordonnées de vertex ont dépassé la constante prédéfinie GLU_TESS_MAX_COORD en valeur absolue et que la valeur a été limitée. (Les valeurs de coordonnées doivent être suffisamment petites pour que deux puissent être multipliées ensemble sans dépassement de capacité.) GLU_TESS_NEED_COMBINE_CALLBACK indique que le pavage a détecté une intersection entre deux arêtes dans les données d’entrée et que le rappel GLU_TESS_COMBINE ou GLU_TESS_COMBINE_DATA n’a pas été fourni. Aucune sortie n’est générée.
GLU_TESS_ERROR_DATA Le rappel GLU_TESS_ERROR_DATA est identique au rappel GLU_TESS_ERROR, sauf qu’il prend un argument de pointeur supplémentaire. Ce pointeur est identique au pointeur opaque fourni lorsque vous appelez gluTessBeginPolygon. Le prototype de fonction pour ce rappel est : voiderrorData (GLenumerrno, void * polygon_data) ;

Spécifications

Condition requise Valeur
Client minimal pris en charge
 Windows 2000 Professionnel [applications de bureau uniquement]
Serveur minimal pris en charge
 Windows 2000 Server [applications de bureau uniquement]
En-tête
Glu.h
Bibliothèque
Glu32.lib
DLL
Glu32.dll

Voir aussi

glBegin

glEdgeFlag

glEnd

glVertex

gluDeleteTess

gluErrorString

gluNewTess

gluTessBeginPolygon

gluTessEndPolygon

gluTessVertex