Subsections

Définir une texture

La création d'une texture nécessite dans un premier temps une image source. Cette image source peut soit être crée à l'intérieur du programme, soit être lue dans un fichier. La définition d'une texture à partir de cette image source s'effectue ensuite en plusieurs étapes3 dont certaines découlent du besoin d'utiliser plusieurs textures de façon simultanée :

  1. Identifier,
  2. spécifier la texture courante,
  3. spécifier le plaquage,
  4. spécifier l'image source,
  5. spécifier le mode de rendu.

Identifier

Pour pouvoir manipuler plusieurs textures, il est nécessaire de les identifier. OpenGL utilise pour cela des entiers. Le choix des entiers peut être fait soit directement, soit à l'aide de la fonction glGenTextures. Cette dernière gère les identifiants de textures et fournit des entiers qui ne sont pas encore utilisés. 
  int textures[n+1];    /* un tableau d'identifiants vide */
  glGenTextures(n, textures);  /* genere n entiers        */
                               /* disponibles             */

Spécifier la texture courante

Il s'agit de spécifier la texture (1D ou 2D) sur laquelle s'appliqueront les opérations ultérieures. Cela se fait par l'identifiant de la texture. 
 glBindTexture(GL_TEXTURE_2D, textures[2]); /* textures[2]   */
                                            /* devient active*/

Spécifier le plaquage

Il s'agit de spécifier la méthode à utiliser pour plaquer la texture courante. Cela se fait à l'aide la fonction glTexParameter. Cette dernière permet de plaquer les textures de différentes manières suivant la fonction de transfert choisie entre l'image destination d'une texture et son image source.

Figure 18: Magnification : la texture, dans l'image finale, a des dimensions supérieures à celles de l'image dont elle provient.
\begin{figure}\begin{center} \scriptsize { \begin{tabular}{\vert p{5.8cm}\vert p... ...ER, GL\_NEAREST) \hline \end{tabular}} %%end small{ \end{center}\end{figure}

Figure 19: Minification : la texture, dans l'image finale, a des dimensions inférieures à celles de l'image dont elle provient.
\begin{figure}\enlargethispage{2cm} \par\vspace{-2cm} \begin{center} \scriptsize... ...AP\_NEAREST) \ \hline \end{tabular}\par } %%end small{ \end{center}\end{figure}

Spécifier l'image de texture

Pour spécifier l'image de texture, il est possible de définir directement l'image concernée (soit un tableau de pixels) ou bien de définir ou de calculer une mipmap (l'image à différents niveaux de résolution) à partir de cette image.

La fonction suivante permet de définir une image de texture : 

glTexImage2D(GL_TEXTURE_2D, 
             Level,              /* niveau de resolution */
             Formatint,          /* format interne       */
             Largeur, Hauteur,   /* dimensions puissances de 2*/
             Bord,              /* largeur du bord (0 ou 1 )*/
             Formatext,          /* format de l'image    */
             Type,               /* type des donnees     */
             Image);             /* tableau de donnees   */
où :

La fonction glTexImage2D peut aussi servir à construire une mipmap en utilisant différentes valeurs du paramètre Level. Par contre, il existe une fonction de la libraire glu qui construit une mipmap directement à partir de l'image initiale et qui, de plus, redimensionne automatiquement l'image si celle-ci n'a pas des dimensions puissances de 2 : 

gluBuild2DMipmaps(GL_TEXTURE_2D, 
                 Formatint,          /* format interne        */
                 Largeur, Hauteur,   /* dimensions de l'image */
                 Formatext,          /* format de l'image    */
                 Type,               /* type des donnees     */
                 Image);             /* tableau de donnees   */

Spécifier le mode de rendu

Enfin, la dernière fonction concerne le mode de rendu à utiliser : soit la texture uniquement, soit la combinaison de la texture et d'un rendu. 
glTexEnvi(GL_TEXTURE_ENV, 
          GL_TEXTURE_ENV_MODE,
          GL_DECAL - GL_REPLACE - GL_MODULATE - GL_BLEND)
la valeur par défaut est GL_MODULATE qui combine le rendu, si celui ci est défini, et la texture. Pour une texture de format RGB, le rendu s'effectue pour chaque composante suivant (voir figure 20):

DECAL REPLACE MODULATE BLEND
texture texture texture × rendu rendu × (1 - texture)

Figure 20: Spécifier le rendu : en fonction du mode rendu choisi, il est possible d'afficher le rendu uniquement, la texture uniquement (GL_DECAL - GL_REPLACE) ou une combinaison des deux (GL_MODULATE - GL_BLEND).
\begin{figure}\begin{center} \scriptsize { \begin{tabular}{\vert p{5.4cm}\vert p... ... glEnable(GL\_TEXTURE\_2D) \end{tabular}} %%end small{ \end{center}\end{figure}

En résumé

Le code suivant illustre l'ensemble des appels de fonctions utiles à l'usage d'une texture : 

void init_texture()
{
  glGenTextures(1,&num_texture);
  glBindTexture(GL_TEXTURE_2D, num_texture);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  image = LoadPNMImage("image.ppm",&ImgWidth,&ImgHeight,&MaxVal);
  //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ImgWidth, ImgHeight,
                 0, GL_RGB, GL_UNSIGNED_BYTE, Image);
  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, ImgWidth, ImgHeight,
                    GL_RGB, GL_UNSIGNED_BYTE, image);
  glEnable(GL_TEXTURE_2D); 
}

Edmond Boyer
2001-03-07