fonction glDrawPixels

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 écrit dans le framebuffer.

height

Dimension de hauteur du rectangle de pixels qui sera écrit 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. 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 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 tous les bits de fraction définis sur zéro. La fonction convertit les données bitmap en 0.0 ou 1.0. La fonction glDrawPixels déplace chaque index à point fixe gauche de GL_INDEX_SHIFT bits et l’ajoute à GL_INDEX_OFFSET. Si GL_INDEX_SHIFT est négatif, le décalage est vers la droite. Dans les deux cas, zéro bits remplit les emplacements de bits non spécifiés dans le résultat. 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. Lorsque dans le mode d’index de couleur et que GL_MAP_COLOR est true, l’index est remplacé par la valeur que glDrawPixels référence dans la table de recherche GL_PIXEL_MAP_I_TO_I. Que la recherche de remplacement de l’index soit effectuée ou non, la partie entière de l’index est ET2b - 1, où b est le nombre de bits dans une mémoire tampon d’index de couleur. Les index résultants ou couleurs RVBA sont ensuite convertis en fragments en attachant la coordonnée 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èmefragment de telle sorte que x? = xr + nmod width y? = yr + n/width où (xr , yr ) est la position raster actuelle. La fonction glDrawPixels traite ces fragments de pixels comme les fragments générés par la rastérisation de points, de lignes ou de polygones. Il applique le mappage de textures, 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. 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 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 tous les bits de fraction définis sur zéro. Les données bitmap sont converties en 0.0 ou 1.0. La fonction glDrawPixels déplace chaque index à point fixe de GL_INDEX_SHIFT bits et l’ajoute à GL_INDEX_OFFSET. Si GL_INDEX_SHIFT est négatif, le décalage est vers la droite. Dans les deux cas, zéro bits remplit les emplacements de bits non spécifiés dans le résultat. Si GL_MAP_STENCIL a la valeur true, l’index est remplacé par la valeur que glDrawPixels référence dans la table de recherche GL_PIXEL_MAP_S_TO_S. Que le remplacement de recherche de l’index soit effectué ou non, la partie entière de l’index est alors ET2b - 1, où b est le nombre de bits dans la mémoire tampon de gabarit. Les index de gabarit résultants sont ensuite écrits dans la mémoire tampon de gabarit de telle sorte que le nièmeindex soit écrit à l’emplacement x ? = xr + nmod width y? = yr + n/width où (xr ,yr ) est la position raster actuelle. Seuls le test de propriété des pixels, le test de ciseaux et le masque d’écriture du gabarit affectent ces écritures.
GL_DEPTH_COMPONENT	Chaque pixel est un composant d’une seule profondeur. 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 linéairement au format à virgule flottante interne, de sorte que la valeur d’entier représentable la plus positive est mappée à 1,0, et la valeur représentable 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. 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 limité à la plage [0,1]. La fonction glDrawPixels convertit les composants de profondeur résultants en fragments en attachant la couleur de position raster actuelle ou l’index de couleur et les coordonnées de texture à chaque pixel, puis en affectant les coordonnées de fenêtre x et y au nième fragment de telle sorte que x? = xr + nmod width y? = yr + n/width où (xr ,yr ) est la position raster actuelle. Ces fragments de pixels sont ensuite traités comme les fragments générés par la rastérisation de points, de lignes ou de polygones. La fonction glDrawPixels applique le mappage de textures, 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. La fonction glDrawPixels convertit directement les valeurs à virgule flottante en un format à virgule flottante interne avec une précision non spécifiée. Les valeurs entières signées sont mappées linéairement au format à virgule flottante interne, de sorte que la valeur d’entier représentable la plus positive est mappée à 1,0, et la valeur représentable 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. La fonction glDrawPixels multiplie les valeurs de couleur à virgule flottante résultantes 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 limités à la plage [0,1]. Si GL_MAP_COLOR a la valeur true, glDrawPixels met à l’échelle chaque composant de couleur en fonction de la taille de la table de choix 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. La fonction glDrawPixels convertit les couleurs RGBA obtenues en fragments en attachant les coordonnées de la coordonnée z et de la texture de position raster actuelles à chaque pixel, puis en affectant les coordonnées de fenêtre x et y au nièmefragment de sorte que x? = xr + nmod width y? = yr + n /width où (xr ,yr ) est la position raster actuelle. Ces fragments de pixels sont ensuite traités comme les fragments générés par la rastérisation de points, de lignes ou de polygones. La fonction glDrawPixels applique le mappage de textures, le brouillard et toutes les opérations de fragment avant d’écrire les fragments dans le framebuffer.
GL_RED	Chaque pixel est un seul composant rouge. 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 le vert et le bleu définis sur 0,0 et alpha sur 1.0. Après cette conversion, le pixel est traité comme s’il avait été lu en tant que pixel RVBA.
GL_GREEN	Chaque pixel est un seul composant vert. 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 RGBA avec le rouge et le bleu définis sur 0.0 et alpha sur 1.0. Après cette conversion, le pixel est traité comme s’il avait été lu en tant que pixel RVBA.
GL_BLUE	Chaque pixel est un seul composant bleu. La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant bleu d’un pixel RVBA, puis le convertit en pixel RVBA avec le rouge et le vert définis sur 0.0 et alpha sur 1.0. Après cette conversion, le pixel est traité comme s’il avait été lu en tant que pixel RVBA.
GL_ALPHA	Chaque pixel est un seul composant alpha. La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même façon que le composant alpha d’un pixel RVBA, puis le convertit en pixel RVBA avec rouge, vert et bleu définis sur 0,0. Après cette conversion, le pixel est traité comme s’il avait été lu en tant que pixel RVBA.
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 rouge, vert et bleu d’un pixel RVBA. 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 composant de luminance unique. La fonction glDrawPixels convertit ce composant au format à virgule flottante interne de la même manière que le composant rouge d’un pixel RGBA, puis le convertit en pixel RGBA avec rouge, vert et bleu défini 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 manière que le composant rouge d’un pixel RGBA, puis les convertit en pixel RGBA avec rouge, vert et bleu défini sur la valeur de luminance convertie, et alpha défini 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 la mémoire des bitmaps indépendantes de l’appareil (DIB) Windows. Ainsi, vos applications peuvent utiliser les mêmes données avec les appels de fonction Windows et les appels de fonction de pixels OpenGL.
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 la mémoire des bitmaps indépendantes de l’appareil (DIB) Windows. Ainsi, vos applications peuvent utiliser les mêmes données avec les appels de fonction Windows et les appels de fonction de pixels OpenGL.

type

Type de données pour les pixels. Voici les constantes symboliques acceptées et leur signification.

Valeur	Signification
GL_UNSIGNED_BYTE	Entier 8 bits non signé
GL_BYTE	Entier 8 bits signé
GL_BITMAP	Bits uniques dans des entiers 8 bits non signés
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 simple précision

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 .

Notes

La fonction glDrawPixels lit les données de pixels à partir de la mémoire et les écrit dans le framebuffer par rapport à la position raster actuelle. Utilisez glRasterPos pour définir la position raster actuelle et utilisez glGet avec l’argument GL_CURRENT_RASTER_POSITION pour interroger la position 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 pixels avant qu’elles ne sont placées 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 d’un grand nombre, mais pas tous, des paramètres spécifiés par ces quatre fonctions.

Les données sont lues à partir de pixels sous la forme d’une séquence d’octets signés ou non signés, de shorts 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, toujours 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 1 bits, l’ordre des bits étant déterminé par GL_UNPACK_LSB_FIRST (voir glPixelStore).

Les pixels de largeur par hauteur sont lus à partir de la mémoire, en commençant par les 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. D’autres paramètres du magasin de pixels spécifient différentes avancées de pointeur de lecture, à la fois avant la lecture du premier pixel et après la lecture de tous les pixels de largeur . La fonction glPixelStore fonctionne sur chacun des pixels de largeur par hauteur qu’elle lit à partir 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, tel que spécifié par format.

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

(x_{r r} + zoom ? n, y_r + zoom_ym)

(x_{r r} + zoom ? (n + 1), y_r + zoom_y (m + 1))

où zoomer ? est la valeur de GL_ZOOM_X et zoom_y est la valeur de GL_ZOOM_Y.

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

glGet avec argument GL_CURRENT_RASTER_POSITION

glGet avec argument GL_CURRENT_RASTER_POSITION_VALID

Spécifications

Voir aussi

glAlphaFunc

glBegin

glBlendFunc

glCopyPixels

glDepthFunc

glEnd

glGet

glLogicOp

glPixelMap

glPixelStore

glPixelTransfer

glPixelZoom

glRasterPos

glReadPixels

glScissor

glStencilFunc