glDrawPixels, fonction

La fonction glDrawPixels écrit un bloc de pixels dans le framebuffer.

Syntaxe

void WINAPI glDrawPixels(
         GLsizei width,
         GLsizei height,
         GLenum  format,
         GLenum  type,
   const GLvoid  *pixels
);

Paramètres

width

Dimension de largeur du rectangle de pixels qui sera écrite dans le framebuffer.

height

Dimension de hauteur du rectangle de pixels qui sera écrite dans le framebuffer.

format

Format des données de pixels. Les constantes symboliques acceptables sont les suivantes.

Valeur Signification
GL_COLOR_INDEX
Chaque pixel est une valeur unique, un index de couleur.
  1. La fonction glDrawPixels convertit chaque pixel au format à point fixe, avec un nombre non spécifié de bits à droite du point binaire, quel que soit le type de données de mémoire. Les valeurs à virgule flottante sont converties en valeurs à virgule fixe vraies. La fonction glDrawPixels convertit les données entières signées et non signées avec toutes les fractions définies sur zéro. La fonction convertit les données bitmap en 0.0 ou 1.0.
  2. La fonction glDrawPixels déplace chaque index de point fixe à gauche par GL_INDEX_SHIFT bits et l’ajoute à GL_INDEX_OFFSET. Si GL_INDEX_SHIFT est négatif, le décalage est à droite. Dans les deux cas, aucun bits ne remplit les emplacements de bits non spécifiés dans le résultat.
  3. En mode RVBA, glDrawPixels convertit l’index résultant en pixel RVBA à l’aide des tables GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B et GL_PIXEL_MAP_I_TO_A. Lorsqu’il est en mode d’index de couleur et que GL_MAP_COLOR a la valeur true, l’index est remplacé par la valeur référencée par glDrawPixels dans la table de recherche GL_PIXEL_MAP_I_TO_I.
  4. Que la recherche de remplacement de l’index soit effectuée ou non, la partie entière de l’index est ANDée avec 2b - 1, où b est le nombre de bits dans une mémoire tampon d’index de couleur.
  5. Les index résultants ou les couleurs RVBA sont ensuite convertis en fragments en attachant les coordonnées z de position de rastérisation et les coordonnées de texture actuelles à chaque pixel, puis en affectant les coordonnées de fenêtre x et y au nième fragment de telle sorte que x ? = Largeur du mod xrn +
    y ? = yrn + /width
    où (xr , yr ) est la position raster actuelle.
  6. La fonction glDrawPixels traite ces fragments de pixels comme les fragments générés par le rastérisation de points, de lignes ou de polygones. Il applique le mappage de texture, le brouillard et toutes les opérations de fragment avant d’écrire les fragments dans le framebuffer.
GL_STENCIL_INDEX
Chaque pixel est une valeur unique, un index de gabarit.
  1. La fonction glDrawPixels la convertit au format à point fixe, avec un nombre non spécifié de bits à droite du point binaire, quel que soit le type de données de mémoire. Les valeurs à virgule flottante sont converties en valeurs à virgule fixe vraies. La fonction glDrawPixels convertit les données entières signées et non signées avec toutes les fractions définies sur zéro. Les données bitmap sont converties en 0.0 ou 1.0.
  2. La fonction glDrawPixels déplace chaque index de point fixe à gauche par GL_INDEX_SHIFT bits et l’ajoute à GL_INDEX_OFFSET. Si GL_INDEX_SHIFT est négatif, le décalage est à droite. Dans les deux cas, aucun bits ne remplit les emplacements de bits non spécifiés dans le résultat.
  3. Si GL_MAP_STENCIL a la valeur true, l’index est remplacé par la valeur référencée par glDrawPixels dans la table de recherche GL_PIXEL_MAP_S_TO_S.
  4. Si le remplacement de recherche de l’index est effectué ou non, la partie entière de l’index est ensuite ANDée avec 2b - 1, où b est le nombre de bits dans la mémoire tampon du gabarit. Les index de gabarit résultants sont ensuite écrits dans la mémoire tampon de gabarit de sorte que le nième index soit écrit à l’emplacement x ? = Largeur du mod xrn +
    y ? = yrn + /width
    où (xr,yr) est la position raster actuelle. Seul le test de propriété des pixels, le test ciseaux et le masque d’écriture de gabarit affectent ces écritures.
GL_DEPTH_COMPONENT
Chaque pixel est un composant à profondeur unique.
  1. La fonction glDrawPixels convertit les données à virgule flottante directement dans un format à virgule flottante interne avec une précision non spécifiée. Les données entières signées sont mappées de façon linéaire au format à virgule flottante interne, de sorte que la valeur entière la plus positive pouvant être représentée est mappée à 1,0 et que la valeur la plus négative est mappée à -1.0. Les données entières non signées sont mappées de la même façon : la plus grande valeur entière est mappée à 1,0 et zéro est mappée à 0,0.
  2. La fonction glDrawPixels multiplie la valeur de profondeur à virgule flottante résultante par GL_DEPTH_SCALE et l’ajoute à GL_DEPTH_BIAS. Le résultat est fixé à la plage [0,1].
  3. La fonction glDrawPixels convertit les composants de profondeur résultants en fragments en attachant la couleur de position ou l’index de couleur et les coordonnées de texture actuelles à chaque pixel, puis en affectant les coordonnées de fenêtre x et y au nième fragment de telle sorte que x ? = Largeur du mod xrn +
    y ? = yrn + /width
    où (xr,yr) est la position raster actuelle.
  4. Ces fragments de pixels sont ensuite traités comme les fragments générés par le rastérisation de points, de lignes ou de polygones. La fonction glDrawPixels applique le mappage de texture, le brouillard et toutes les opérations de fragment avant d’écrire les fragments dans le framebuffer.
GL_RGBA
Chaque pixel est un groupe à quatre composants dans cet ordre : rouge, vert, bleu, alpha.
  1. La fonction glDrawPixels convertit les valeurs à virgule flottante directement en un format à virgule flottante interne avec une précision non spécifiée. Les valeurs entières signées sont mappées de façon linéaire au format à virgule flottante interne, de sorte que la valeur entière la plus positive pouvant être représentée est mappée à 1,0 et que la valeur représentée la plus négative est mappée à -1.0. Les données entières non signées sont mappées de la même façon : la plus grande valeur entière est mappée à 1,0 et zéro est mappée à 0,0.
  2. La fonction glDrawPixels multiplie les valeurs de couleur à virgule flottante obtenues par GL_c_SCALE et les ajoute à GL_c_BIAS, où c est ROUGE, VERT, BLEU et ALPHA pour les composants de couleur respectifs. Les résultats sont fixés à la plage [0,1].
  3. Si GL_MAP_COLOR a la valeur true, glDrawPixels met à l’échelle chaque composant de couleur par la taille de la table de recherche GL_PIXEL_MAP_c_TO_c, puis remplace le composant par la valeur qu’il référence dans cette table ; c est R, G, B ou A, respectivement.
  4. La fonction glDrawPixels convertit les couleurs RVBA obtenues en fragments en attachant les coordonnées z et les coordonnées de texture actuelles de position raster à chaque pixel, puis en affectant les coordonnées de fenêtre x et y au nième fragment de telle sorte que x ? = Largeur du mod xrn +
    y ? = yrn + /width
    où (xr,yr) est la position raster actuelle.
  5. Ces fragments de pixels sont ensuite traités comme les fragments générés par le rastérisation de points, de lignes ou de polygones. La fonction glDrawPixels applique le mappage de texture, le brouillard et toutes les opérations de fragment avant d’écrire les fragments dans le framebuffer.
GL_RED
Chaque pixel est un composant rouge unique.
La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant rouge d’un pixel RGBA, puis le convertit en pixel RVBA avec un pixel RVBA avec un paramètre vert et bleu défini sur 0,0 et alpha défini sur 1,0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RGBA.
GL_GREEN
Chaque pixel est un composant vert unique.
La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant vert d’un pixel RGBA, puis le convertit en pixel RVBA avec un pixel RVBA avec une valeur rouge et bleue définie sur 0,0 et alpha définie sur 1,0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RGBA.
GL_BLUE
Chaque pixel est un composant bleu unique.
La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant bleu d’un pixel RGBA, puis le convertit en pixel RGBA avec un pixel RVBA avec une valeur rouge et verte définie sur 0,0 et alpha définie sur 1,0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RGBA.
GL_ALPHA
Chaque pixel est un composant alpha unique.
La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant alpha d’un pixel RGBA, puis le convertit en pixel RVBA avec rouge, vert et bleu défini sur 0,0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RGBA.
GL_RGB
Chaque pixel est un groupe de trois composants dans cet ordre : rouge, vert, bleu. La fonction glDrawPixels convertit chaque composant au format à virgule flottante interne de la même façon que les composants rouges, verts et bleus d’un pixel RGBA. Le triple de couleur est converti en pixel RVBA avec alpha défini sur 1,0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RVBA.
GL_LUMINANCE
Chaque pixel est un seul composant de luminance.
La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant rouge d’un pixel RVBA, puis le convertit en pixel RVBA avec une valeur rouge, verte et bleue définie sur la valeur de luminance convertie, et alpha définie sur 1.0. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RVBA.
GL_LUMINANCE_ALPHA
Chaque pixel est un groupe de deux composants dans cet ordre : luminance, alpha.
La fonction glDrawPixels convertit les deux composants au format à virgule flottante interne de la même façon que le composant rouge d’un pixel RVBA, puis les convertit en pixel RVBA avec rouge, vert et bleu défini sur la valeur de luminance convertie, et alpha définie sur la valeur alpha convertie. Après cette conversion, le pixel est traité comme s’il avait été lu comme un pixel RVBA.
GL_BGR_EXT
Chaque pixel est un groupe de trois composants dans cet ordre : bleu, vert, rouge.
GL_BGR_EXT fournit un format qui correspond à la disposition de mémoire de Windows bitmap indépendantes des appareils (DIBs). Ainsi, vos applications peuvent utiliser les mêmes données avec les appels de fonction Windows et les appels de fonction OpenGL pixels.
GL_BGRA_EXT
Chaque pixel est un groupe de quatre composants dans cet ordre : bleu, vert, rouge, alpha.
GL_BGRA_EXT fournit un format qui correspond à la disposition de mémoire des bitmaps indépendantes de l’appareil (DIBs) Windows. Ainsi, vos applications peuvent utiliser les mêmes données avec les appels de fonction Windows et les appels de fonction OpenGL pixels.

type

Type de données pour les pixels. Voici les constantes symboliques acceptées et leurs significations.

Valeur Signification
GL_UNSIGNED_BYTE
Entier 8 bits non signé
GL_BYTE
Entier 8 bits signé
GL_BITMAP
Bits uniques dans des entiers non signés 8 bits
GL_UNSIGNED_SHORT
Entier 16 bits non signé
GL_SHORT
Entier 16 bits signé
GL_UNSIGNED_INT
Entier 32 bits non signé
GL_INT
Entier de 32 bits
GL_FLOAT
Virgule flottante à précision unique

Pixels

Pointeur vers les données de pixels.

Valeur renvoyée

Cette fonction ne retourne pas de valeur.

Codes d’erreur

Les codes d’erreur suivants peuvent être récupérés par la fonction glGetError .

Nom Signification
GL_INVALID_VALUE
La largeur ou la hauteur étaient négatives.
GL_INVALID_ENUM
Le format ou le type n’était pas une valeur acceptée.
GL_INVALID_OPERATION
le format était GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_BGR_EXT, GL_BGRA_EXT, GL_LUMINANCE ou GL_LUMINANCE_ALPHA, et OpenGL était en mode d’index de couleur.
GL_INVALID_ENUM
le type était GL_BITMAP et le format n’était pas GL_COLOR_INDEX ou GL_STENCIL_INDEX.
GL_INVALID_OPERATION
le format était GL_STENCIL_INDEX et il n’y avait pas de mémoire tampon de gabarit.
GL_INVALID_OPERATION
La fonction a été appelée entre un appel à glBegin et l’appel correspondant à glEnd.

Notes

La fonction glDrawPixels lit les données pixels de la mémoire et l’écrit dans le framebuffer par rapport à la position de raster actuelle. Utilisez glRasterPos pour définir la position de raster actuelle et utilisez glGet avec l’argument GL_CURRENT_RASTER_POSITION pour interroger la position de raster.

Plusieurs paramètres définissent l’encodage des données de pixels en mémoire et contrôlent le traitement des données de pixel avant de les placer dans le framebuffer. Ces paramètres sont définis avec quatre fonctions : glPixelStore, glPixelTransfer, glPixelMap et glPixelZoom. Cette rubrique décrit les effets sur glDrawPixels de nombreux, mais pas tous, des paramètres spécifiés par ces quatre fonctions.

Les données sont lues à partir de pixels en tant que séquence d’octets signés ou non signés, de courts signés ou non signés, d’entiers signés ou non signés ou de valeurs à virgule flottante à précision unique, selon le type. Chacun de ces octets, shorts, entiers ou valeurs à virgule flottante est interprété comme un composant de couleur ou de profondeur, ou un index, selon le format. Les index sont toujours traités individuellement. Les composants de couleur sont traités comme des groupes d’une, deux, trois ou quatre valeurs, à nouveau en fonction du format. Les index individuels et les groupes de composants sont appelés pixels. Si le type est GL_BITMAP, les données doivent être des octets non signés et le format doit être GL_COLOR_INDEX ou GL_STENCIL_INDEX. Chaque octet non signé est traité comme huit pixels de 1 bits, avec un ordre de bits déterminé par GL_UNPACK_LSB_FIRST (voir glPixelStore).

La largeur par pixels de hauteur est lue à partir de la mémoire, en commençant à des pixels d’emplacement. Par défaut, ces pixels sont extraits des emplacements de mémoire adjacents, sauf qu’une fois tous les pixels de largeur lus, le pointeur de lecture est avancé vers la limite de 4 octets suivante. La fonction glPixelStore spécifie l’alignement de ligne de 4 octets avec l’argument GL_UNPACK_ALIGNMENT, et vous pouvez le définir sur 1, 2, 4 ou 8 octets. Les autres paramètres de magasin de pixels spécifient des avancements de pointeur de lecture différents, tant avant que le premier pixel ne soit lu, et une fois que tous les pixels de largeur sont lus. La fonction glPixelStore fonctionne sur chacun des pixels de largeur par hauteur qu’elle lit de la mémoire de la même façon, en fonction des valeurs de plusieurs paramètres spécifiés par glPixelTransfer et glPixelMap. Les détails de ces opérations, ainsi que la mémoire tampon cible dans laquelle les pixels sont dessinés, sont spécifiques au format des pixels, comme spécifié par format.

La ratérisation décrite jusqu’à présent suppose que les facteurs de zoom des pixels de 1,0. Si vous utilisez glPixelZoom pour modifier les facteurs de zoom x et y pixels, les pixels sont convertis en fragments comme suit. Si (xr,yr) est la position de raster actuelle, et qu’un pixel donné se trouve dans la nièmecolonne et la ligne mth du rectangle de pixels, les fragments sont générés pour les pixels dont les centres se trouvent dans le rectangle avec des angles à l’emplacement

(xr) + zoom ? n, yrzoomym + )

(xr) + zoom ? (n + 1), yrzoomy + (m + 1))

zoomer ? est la valeur de GL_ZOOM_X et le zoomest la valeur de GL_ZOOM_Y.

Les fonctions suivantes récupèrent des informations liées à glDrawPixels :

glGet avec l’argument GL_CURRENT_RASTER_POSITION

glGet avec l’argument GL_CURRENT_RASTER_POSITION_VALID

Configuration requise

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
Gl.h
Bibliothèque
Opengl32.lib
DLL
Opengl32.dll

Voir aussi

glAlphaFunc

glBegin

glBlendFunc

glCopyPixels

glDepthFunc

glEnd

glGet

glLogicOp

glPixelMap

glPixelStore

glPixelTransfer

glPixelZoom

glRasterPos

glReadPixels

glScissor

glStencilFunc