Gl.CopyPixels (gb.opengl)

Copie les pixels dans le tampon de trame

Paramètres

x, y

Spécifie les coordonnées fenêtre du coin inférieur gauche de la région rectangulaire de pixels à copier.

Width, Heigh

Spécifient les dimensions de la région rectangulaire de pixels à copier. Aucun d’eux ne doit être négatif.

type

Spécifie si les valeurs de couleur, de profondeur , ou de pochoir (stencil) doivent être copiées. Les constantes symboliques GL_COLOR, Gl.GL_DEPTH et Gl.GL_STENCIL sont acceptées.

Description

Gl.CopyPixels copie un rectangle de pixels aligné sur l’écran à partir de l’emplacement du tampon de trame vers une région relative à la position 'raster' courante. Cette opération n’est bien définie que si les pixels de la région source sont entièrement compris dans la portion de fenêtre visible. Le résultat de copies à partir de l’extérieur de la fenêtre, ou de régions de la fenêtre non visibles, dépendent du hardware et sont indéfinies.

x et y spécifient les coordonnées du coin inférieur gauche de la région rectangulaire à copier.. Width et Height specifient les dimensions de la région rectangulaire de pixels à copier. Les deux ne doivent pas être négatifs.

Plusieurs paramètres contrôlent le traitement des données pixel pendant la copie. Ces paramètres sont définis par trois commandes : Gl.PixelTransfer, Gl.PixelMap, et Gl.PixelZoom. Cette page de référence décrit les effets sur Gl.CopyPixels de la plupart, mais pas tous, des paramètres spécifiés par ces trois commandes.

Gl.CopyPixels copie les valeurs de chaque pixel à partir du coin inférieur gauche à$\left(\mathit{x}+\mathit{i},\mathit{y}+\mathit{j}\right)$ pour et . Ce pixel est appelé le $\mathit{i}$ ème pixel dans la $\mathit{j}$ème rangée. Les pixels sont copiés dans l’ordre des rangées de la plus basse à la plus haute, de gauche à droite pour chaque rangée.

type spécifie si les données de couleur, profondeur, ou pochoir doivent être copiées. Les détails du transfert de chaque type de donnée sont comme suit :

Gl.COLOR

Les Indices ou couleurs RGBA sont lus dans le tampon spécifié en tant que tampon source de lecture (voir Gl.ReadBuffer). Si GL est en mode couleurs indexées, chaque index lu depuis ce tampon est converti au format point binaire fixe avec nombre non spécifié de bits à droite du point binaire. Chaque index est alors décalé à gauche de Gl.INDEX_SHIFT bits, et ajouté à Gl.INDEX_OFFSET. Si Gl.INDEX_SHIFT est négatif, le décalage est vers la droite. Dans les deux cas, des bits zéro complètent, dans le résultat, les emplacements non spécifiés. Si Gl.MAP_COLOR est vrai, l’index est remplacé par la valeur qu’il référence dans la table de lookup Gl.PIXEL_MAP_I_TO_I. Que le remplacement de lookup de l’index soit réalisé ou non, un et logique est appliqué à la partie entière de l’index avec $2^{\mathit{b}}-1$, où $\mathit{b}$ est le nombre de bits du tampon d’index de couleur.

Si GL est en mode RGBA, les composantes rouge, verte, bleue et alpha de chaque pixel lu sont converties en un format virgule flottante interne sans précision spécifiée. La conversion cartographie la valeur de composant représentable la plus grande à 1.0, et la valeur de composant 0 à 0.0. Les valeurs flottantes de couleur résultantes sont ensuite multipliées par Gl.c_SCALE et ajoutées à Gl.c_BIAS, où c sont ROUGE, VERT, BLEUE, et ALPHA pour les composantes couleur respectives. Les résultats sont normés dans l’étendue /wiki/0,1. Si Gl.MAP_COLOR est vrai, chaque composante couleur est mise à l’échelle selon la taille de la table lookup Gl.PIXEL_MAP_c_TO_c, Puis remplacée par la valeur qu’elle référence dans la table. c est R, G, B, ou A.

Si l’ extension ARB_imaging est prise en compte, les valeurs de couleur peuvent être calculées additivement avec la table de lookups couleur, la matrice de transformation de couleurs et les filtres de convolution.

GL convertit ensuite l’indice résultant ou les couleurs RGBA en fragments en lui rattachant la coordonnée de position raster courante z, et les coordonnées de texture de chaque pixel, puis lui assignant les coordonnées fenêtre $\left({\mathit{x}}_{\mathit{r}}+\mathit{i},{\mathit{y}}_{\mathit{r}}+\mathit{j}\right)$, où $\left({\mathit{x}}_{\mathit{r}},{\mathit{y}}_{\mathit{r}}\right)$ est la position raster courante, et le pixel le $\mathit{i}$ème pixel dans la $\mathit{j}$ème rangée. Ces pixels fragmentaires sont alors traités exactement comme les fragments générés par la ‘rastérisation’ des points, lignes ou polygones. L’application de texture, de brume, et toutes les opérations sur fragment sont appliquées avant l’écriture du fragment dans le tampon de trame.

Gl.DEPTH

Les valeurs de profondeur sont lues dans le tampon de profondeur et converties directement en un format interne de flottant sans précision précisée. Le flottant valeur de profondeur résultant est ensuite multiplié par Gl.DEPTH_SCALE et ajouté à Gl.DEPTH_BIAS. Le résultat est normé dans l’étendue /wiki/0,1.

Gl convertit ensuite les composantes de profondeur résultantes en fragments en rattachant la position ‘raster’ courante ou l’indice de couleur et les coordonnées de texture à chaque pixel, assignant ensuite les coordonnées fenêtre $\left({\mathit{x}}_{\mathit{r}}+\mathit{i},{\mathit{y}}_{\mathit{r}}+\mathit{j}\right)$, où $\left({\mathit{x}}_{\mathit{r}},{\mathit{y}}_{\mathit{r}}\right)$ est la position raster courante, et le pixel le $\mathit{i}$ème pixel dans la $\mathit{j}$ème rangée. Ces pixels fragmentaires sont alors traités exactement comme les fragments générés par la ‘rastérisation’ des points, lignes ou polygones. L’application de texture, de brume, et toutes les opérations sur fragment sont appliquées avant l’écriture du fragment dans le tampon de trame.

Gl.STENCIL

Les indices de pochoir sont lus dans le tampon pochoir et convertis en format interne à point décimal fixe avec un nombre non spécifié de bits à droite du point binaire. Chaque index point fixe est ensuite décalé vers la gauche de Gl.INDEX_SHIFT bits, et ajouté à Gl.INDEX_OFFSET. Si Gl.INDEX_SHIFT est négatif, le décalage est vers la droite. Dans les deux cas, des bits zéro complètent les emplacement non spécifiés dans le résultat. Si Gl.MAP_STENCIL est vrai, l’indice est remplacé par la valeur qu’il référence dans la table de lookup Gl.PIXEL_MAP_S_TO_S. Que le remplacement de lookup de l’indice soit réalisé ou non, un et logique est appliqué avec $2^{\mathit{b}}-1$, où $\mathit{b}$ est le nombre de bits dans le tampon de pochoir. Les indices de pochoir résultants sont alors écris dans le tampon pochoir de telle sorte que l’index lu dans la $\mathit{i}$ème position de la $\mathit{j}$ème rangée soit écrite dans l’emplacement $\left({\mathit{x}}_{\mathit{r}}+\mathit{i},{\mathit{y}}_{\mathit{r}}+\mathit{j}\right)$, où $\left({\mathit{x}}_{\mathit{r}},{\mathit{y}}_{\mathit{r}}\right)$ est la position raster en cours. Seul le test d’appartenance, le test de découpage et le masque de pochoir affectent ces opérations d’écriture.

La ‘rasterisation’ décrite jusque là suppose un facteur de zoom de pixel égal à 1.0. Si Gl.PixelZoom est utilisé pour changer les facteurs de zoom $\mathit{x}$ et $\mathit{y}$, les pixels sont convertis en fragment comme suit. Si $\left({\mathit{x}}_{\mathit{r}},{\mathit{y}}_{\mathit{r}}\right)$ est la position raster en cours, et qu’un pixel donné est dans la $\mathit{i}$ème position de la $\mathit{j}$ème rangée du rectangle source, les fragments sont alors générés pour les pixels dont le centre appartiennet au rectangle dont les sommets sont à $\left({\mathit{x}}_{\mathit{r}}+{\mathit{zoom}}_{\mathit{x}}\mathit{i},{\mathit{y}}_{\mathit{r}}+{\mathit{zoom}}_{\mathit{y}}\mathit{j}\right)$

et

$\left({\mathit{x}}_{\mathit{r}}+{\mathit{zoom}}_{\mathit{x}}\left(\mathit{i}+1\right),{\mathit{y}}_{\mathit{r}}+{\mathit{zoom}}_{\mathit{y}}\left(\mathit{j}+1\right)\right)$

où ${\mathit{zoom}}_{\mathit{x}}$ est la valeur de Gl.ZOOM_X et ${\mathit{zoom}}_{\mathit{y}}$ la valeur de Gl.ZOOM_Y.

Exemples

Pour copier la couleur du pixel du coin inférieur gauche de la fenêtre à la position raster courante, utilisez

glCopyPixels(0, 0, 1, 1, Gl.COLOR);

Notes

Les modes spécifiés par Gl.PixelStore sont sans effet sur les opérations de Gl.CopyPixels.

Errors

Gl.INVALID_ENUM est générée si type n’est pas une valeur acceptée.

Gl.INVALID_VALUE est générée si soit Width soit Height est négatif.

Gl.INVALID_OPERATION est générée si type est un Gl.DEPTH et qu’il n’y a pas de tampon de profondeur.

Gl.INVALID_OPERATION est générée si type est un Gl.STENCIL et qu’il n’y a pas de tampon de pochoir.

Gl.INVALID_OPERATION est générée si Gl.CopyPixels est exécuté entre l’exécution de Gl.Begin et l’exécution correspondante de Gl.End.

_ Gets Associés

Gl.Get avec l’argument Gl.CURRENT_RASTER_POSITION

Gl.Get avec l’argument Gl.CURRENT_RASTER_POSITION_VALID

Voir aussi

Voir la documentation originale sur OpenGL website