Transcript OpenGL Couleur.

Couleur
1er mode de représentation des
couleurs : mode RVBA

Un objectif souvent visé est de permettre de spécifier une couleur
indépendamment du nombre de bits disponible par pixel dans la mémoire
d’entretien. Une couleur « approchée » sera alors calculée.

Une technique utilisée est l’emploi d’un cube unitaire où les composantes
d’une couleur sont déterminées en fixant un paramètre pour chaque couleur
primaire (une valeur entre 0 et 1), rouge, vert et bleu.
La couleur d’un pixel est indépendante des autres pixels.
Ex. :
Pour afficher la couleur rouge la plus brillante, on opte pour :
glColor3f(1.0, 0.0, 0.0);
où 3f représente les 3 composantes réelles d’une couleur.
Ex. :
Nous continuerons à afficher en rouge tant et aussi longtemps que
cet attribut ne change pas.
glClearColor(1.0, 1.0, 1.0, 0.0);
Efface l’écran avec la couleur blanche (1.0, 1.0, 1.0) et avec un
2
caractère opaque (aucune transparence) (0.0).
Spécifier une couleur en mode RVBA
Note :
Dans le cas où les données sont définies en virgule flottante, les valeurs
doivent se trouver entre 0.0 et 1.0.
3
2ième mode de représentation des
couleurs : table de couleurs




Considérons le cas où la résolution de l’écran est 1280x1024 avec des pixels
de 8 bits. La stratégie qui consiste à constituer des groupes de bits par pixel
pour chaque couleur primaire est à revoir.
Une autre approche consiste à simuler celle du peintre : à l’aide d’un nombre
limité de tubes de couleurs, il peut produire un nombre presque infini de
couleurs.
Il sera donc disponible une palette de couleurs très large mais un nombre
réduit de couleurs sera présent dans une image donnée.
Pour y arriver, chaque « pixel » contiendra un indice dans une table plutôt
qu’une couleur.
Si chaque «pixel» a k bits, l’indice d’un «pixel» varie entre 0 et 2k– 1.
En supposant que nous pouvons afficher des couleurs avec une précision de
m bits i.e., nous avons un choix de 2m rouges, 2m verts et 2m bleus.
D’où nous avons une palette de 23m couleurs mais la mémoire d’entretien
4
peut en désigner seulement 2k parmi celles-ci.
Table de couleurs

La table de couleurs de dimension 2k x3m est :
Entrée
Rouge
Vert
Bleu
0
La taille de la table des couleurs
est toujours une puissance de 2.
.
.
Si le contenu d’une entrée de la
table des couleurs change, tous
les pixels de cet index couleur
sont modifiés.
.
2k– 1
m bits
m bits
m bits
5
Table de couleurs

L’usager initialise la table avec les couleurs désirées en utilisant m bits pour
chaque couleur primaire.

Une fois l’usager a construit la table, une couleur peut être spécifiée par son
indice dans la table.
Ex. : k = m = 8
L’usager peut choisir 256 couleurs parmi 16M couleurs.
Note :
Au début de l’exécution d’un programme, le mode d’affichage de la couleur est
le mode RVBA ou le mode index couleur. Une fois qu’il est initialisé, ce mode
ne peut plus être modifié.
La valeur alpha (le A de RVBA) n’a pas d’effet direct sur la couleur affichée à
l’écran. Elle sert au mélange des couleurs et à la transparence.
6
Spécifier une couleur en mode index de couleur
On doit utiliser la commande glIndex*() pour sélectionner un index couleur à
valeur unique comme index couleur actif :
La commande correspondante à glClearColor() en mode index couleur est
glClearIndex() :
void glClearIndex(GLfloat cindex);
7
Comment choisir entre les 2 modes ?
Cela dépend du matériel dont vous disposez et des besoins de l’application.
Sur la plupart des ordinateurs, vous pouvez représenter simultanément plus de
couleurs en mode RVBA qu’en mode index couleur.
Le mode RVBA offre plus de souplesse pour les effets de dégradé, d’éclairage,
de texture et de brouillard.
Le mode index de couleur peut être préférable si le # de bits par pixel est petit.
Si vos exigences en matière de dégradé sont réduites, par exemple, s’il ne vous faut
que des nuances de bleu, il serait bon d’utiliser le mode index couleur.
8
Spécifier un modèle de dégradé
Une primitive peut être affichée avec une seule couleur (la couleur active) ou
avec de nombreuses couleurs différentes (dégradés).
void glShadeModel(GLenum mode);
Définit le modèle de dégradé. Le paramètre mode peut prendre
comme valeur :
GL_SMOOTH : la couleur de chaque sommet est traitée
individuellement et on procède par interpolation à
l’intérieur de la figure géométrique (valeur par défaut).
GL_FLAT :
une seule couleur.
9
Exemple de dégradé : un cube de couleurs
GLfloat sommets[][3] =
{
{-1.0, -1.0, -1.0}, {1.0, -1.0, -1.0},
{1.0, 1.0, -1.0}, {-1.0, 1.0, -1.0},
{-1.0, -1.0, 1.0}, {1.0, -1.0, 1.0},
{1.0, 1.0, 1.0}, {-1.0, 1.0, 1.0}};
GLfloat couleurs[][3] = {
{0.0, 0.0, 0.0}, {1.0, 0.0, 0.0},
{1.0, 1.0, 0.0}, {0.0, 1.0, 0.0},
{0.0, 0.0, 1.0}, {1.0, 0.0, 1.0},
{1.0, 1.0, 1.0}, {0.0, 1.0, 1.0}};
void polygone(int a, int b, int c, int d)
/*
Afficher un polygone à partir d'une liste de sommets.
Le mode d'affichage par défaut est celui par remplissage */
{
glBegin(GL_POLYGON);
glColor3fv(couleurs[a]);
glVertex3fv(sommets[a]);
glColor3fv(couleurs[b]);
glVertex3fv(sommets[b]);
glColor3fv(couleurs[c]);
glVertex3fv(sommets[c]);
glColor3fv(couleurs[d]);
glVertex3fv(sommets[d]);
glEnd();
10
}
Exemple de dégradé : un cube de couleurs
void cube_de_couleurs(void)
/* Relier les sommets aux facettes polygonales */
{
polygone(0, 3, 2, 1);
polygone(2, 3, 7, 6);
polygone(1, 2, 6, 5);
polygone(4, 5, 6, 7);
}
polygone(0, 4, 7, 3);
polygone(0, 1, 5, 4);
void Initialisation(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2.0, 2.0, -2.0, 2.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
}
11
Exemple de dégradé : un cube de couleurs
void affichage( void )
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glRotatef(theta[0], 1.0, 0.0, 0.0);
glRotatef(theta[1], 0.0, 1.0, 0.0);
glRotatef(theta[2], 0.0, 0.0, 1.0);
cube_de_couleurs();
/*
Cela force le système à afficher les points aussitôt que possible. */
glFlush();
/*
Permet de transférer l'image à l'écran.
*/
glutSwapBuffers();
}
etc.
12
Usage d’une table d’index de couleurs
void glutSetColor(Gint index, GLfloat rouge, GLfloat vert, GLfloat bleu);
Initialise la couleur d’indice index avec les paramètres rouge, vert et bleu.
Ces 3 valeurs sont normalisées pour se retrouver dans l’intervalle [0.0, 1.0].
Ex.: GLfloat sommets[][3] = { {-1.0, -1.0, -1.0}, {1.0, -1.0, -1.0}, {1.0, 1.0, -1.0},
{-1.0, 1.0, -1.0}, {-1.0, -1.0, 1.0}, {1.0, -1.0, 1.0},
{1.0, 1.0, 1.0}, {-1.0, 1.0, 1.0}};
GLint index_couleur[] = {0, 1, 2, 3, 4, 5, 6, 7};
void polygone(GLint a, GLint b, GLint c, GLint d)
/*
Afficher un polygone à partir d'une liste de sommets.
Le mode d'affichage par défaut est celui par remplissage */
{
glBegin(GL_POLYGON);
glIndexi(index_couleur[a]);
glVertex3fv(sommets[a]);
glIndexi(index_couleur[b]);
glVertex3fv(sommets[b]);
glIndexi(index_couleur[c]);
glVertex3fv(sommets[c]);
glIndexi(index_couleur[d]);
glVertex3fv(sommets[d]);
glEnd();
13
}
void cube_de_couleurs(void)
/* Relier les sommets aux facettes polygonales */
{
polygone(0, 3, 2, 1);
polygone(2, 3, 7, 6);
polygone(0, 4, 7, 3);
polygone(1, 2, 6, 5);
polygone(4, 5, 6, 7);
polygone(0, 1, 5, 4);
}
14
void Initialisation(void)
{
glutSetColor(0, 0.0, 0.0, 0.0);
glutSetColor(2, 1.0, 1.0, 0.0);
glutSetColor(4, 0.0, 0.0, 1.0);
glutSetColor(6, 1.0, 1.0, 1.0);
/*
glutSetColor(1, 1.0, 0.0, 0.0);
glutSetColor(3, 0.0, 1.0, 0.0);
glutSetColor(5, 1.0, 0.0, 1.0);
glutSetColor(7, 0.0, 1.0, 1.0);
Permet d'initialiser la couleur de fond en choisissant l'index 0.*/
glClearIndex(0);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2.0, 2.0, -2.0, 2.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
}
15
void main(int argc, char** argv)
{
glutInit(&argc, argv);
/*
Permet de fixer les modalités d'affichage à l'écran.
Les couleurs seront spécifiées à partir d'une table de couleurs.
On opte aussi pour 2 blocs de mémoire tampon supplémentaires,
l'un, pour ranger l'image en construction, l'autre, nécessaire
pour résoudre le problème d'élimination des parties cachées. */
glutInitDisplayMode (GLUT_INDEX | GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(500, 500);
glutInitWindowPosition(800, 300);
glutCreateWindow("Cube de couleur");
glutReshapeFunc(reconfiguration);
glutDisplayFunc(affichage);
glutIdleFunc(cube_en_rotation);
glutMouseFunc(souris);
glEnable(GL_DEPTH_TEST);
Initialisation();
glutMainLoop();
}
etc.
16
Non fonctionnel sous WINDOWS (erreur fatale)