Gestion dynamique de la lumière avec OpenGL - Partie 1 : l'éclairage par vertex

Date de publication : 06/09/2006

Par Michel de VERDELHAN (mdeverdelhan.developpez.com)
 

I. But de ce tutoriel.

1. L'éclairage par vertex.
2. Le light mapping dynamique simple.
3. Le light mapping dynamique avec texture 3D.
4. L'éclairage par pixel simple.
5. L'éclairage par pixel standard.
6. La création d'un système d'éclairage complexe basé sur les shaders.

II. Pourquoi mettre en place son propre système de gestion de la lumière.

• L'éclairage est calculé par vertex.
  Cette façon de gérer l'éclairage oblige à avoir un nombre de polygones élevé pour obtenir une qualité d'éclairage intéressante. En effet, l'éclairage étant interpolé entre les sommets d'un polygone, si les polygones sont trop étendus, l'éclairage ne sera pas bon au centre du polygone. La seule solution pour résoudre ce problème est de découper les grand polygones en plusieurs petits polygones (on parle d'augmentation de la tesselation). Cette solution résout relativement bien le problème de l'interpolation de la lumière, mais elle a aussi comme conséquence d'augmenter fortement la géométrie ce qui a un impact important sur les performances, notamment au niveau de :
  - l'envoi de la géométrie à la carte 3D
  - l'utilisation de certains algorithmes (par exemple : les collisions) qui seront plus coûteux, ou encore pour le calcul des ombres volumétriques qui dépendent fortement de la géométrie.
• L'éclairage étant calculé par la carte graphique, le nombre de lumières utilisables simultanément est limité par le matériel. C'est principalement cette limitation qui impose la mise en place de systèmes de gestion de la lumière dans les moteurs 3D. En effet, on imagine mal un jeu moderne qui ne permet d'avoir que 8 lumières dans un niveau. Il existe bien entendu des méthodes qui permettent d'activer/désactiver des lumières quand elles ne sont plus visibles. Ceci permet de repousser la limite du nombre de lumières, mais cette limite existe toujours. Imaginez un très grand hangar avec seulement 8 lumières là où on en aurait mis plusieurs dizaines dans la réalité, le résultat risque de ne pas être très crédible.

III. Les différents modèles d'éclairage.

Je ne détail pas ici les modèles de Phong et Blinn, mais le net regorge de sites qui les traitent très bien.

1. La composante ambiante : elle correspond à la luminosité minimum de la scène.
   Elle permet en fait de simuler les sources de lumières indirectes. En effet, dans la réalité, les objets sont éclairé par 2 types de sources lumineuses : les sources directes et les sources indirectes. Les sources directes sont les générateurs de lumières (ampoule, soleil et autre), et les sources indirectes sont des objets qui ont reçu de la lumière et en restituent une partie.
   Comme les algorithmes de calcul de restitution de la lumière indirecte ont une complexité temporelle trop importante pour être utilisé en temps réel, le résultat est approché en utilisant une couleur ambiante commune à toute la scène.
2. La composante diffuse : elle correspond à la lumière reçu par l'objet. Elle varie en fonction de la distance et de l'orientation de la surface par rapport à la lumière. Le calcule de la lumière diffuse est généralement
   
   diffuse = N.L * atténuation
   
   Ou diffuse est la couleur diffuse, N est le vecteur normal à la surface, L le vecteur allant de la surface à la lumière, atténuation est le facteur d'atténuation en fonction de la distance, et le . représente le produit scalaire entre les deux vecteurs.

l'éclairage d'une surface est fonction de la normale à la surface et de la direction vers la lumière

Ce calcul est généralement nommé NdotL (dot représentant le produit scalaire) dans la littérature, nous utiliserons donc ce terme au cours des tutoriaux

3. La composante spéculaire : elle correspond à la réflexivité de la surface. Par exemple, une surface métallique brillante aura une forte composante spéculaire alors qu'un pneu de voiture n'en aura pas.
4. La composante émissive : plus anecdotique, la composante émissive correspond à la lumière émise par la surface. Cette composante est toujours affichée même quand la surface est ombrée.

III-1. L'éclairage par vertex

III-2. Le light mapping

1. Le rendu de la scène en utilisant la texture d'éclairage. Les parties dans l’ombre sont affichées en noir alors que le reste est affiché dans la couleur de l'éclairage local.
2. Le rendu de la scène avec la texture normale, en multipliant la couleur précédente. Ainsi, si la couleur précédente était du noir, le résultat final sera du noir, donc une zone ombrée. Si la couleur précédente était du blanc, la couleur final obtenu est celle de la texture, donc une zone éclairée.

III-3. L'éclairage par pixel

III-4. Autres modèles

IV. Un premier système de gestion de la lumière : l'éclairage par vertex.

IV-1. Principe de l'éclairage par vertex

initialiser la luminosite de tout les vertex a la lumiere ambiante
pour chaque lumiere
pour chaque face
pour chaque vertex de la face
vertex.couleur = lumière.couleur * (NdotL) * atténuation
fin pour
fin pour
fin pour
rendre la scène

IV-2. Structure de données.

1. Les positions des vertex.
2. Les normales.
3. Les coordonnées de textures.
4. Les faces.

struct Face
{
	unsigned int vertexIndex[3];
	unsigned int texCoordIndex[3];
	unsigned int normalIndex[3];
	Color color[3];
};

class Model
{
private:
	Vecteur * vertex;
	Vecteur * normals;
	TexCoord * texCoords;
	Face * faces;
	int nbVertex;
	int nbNormals;
	int nbTexCoord;
	int nbFaces;
public:
	Model(void);
	virtual ~Model(void);
	bool load(const std::string & filePath);
	void initLighting(const Color& ambiant);
	void addLight(Light& light);
	void render();
};

void Model::initLighting(const Color& ambiant)
{
	for (int i = 0; i < nbFaces; i++)
	{
		faces[i].color[0] = ambiant;
		faces[i].color[1] = ambiant;
		faces[i].color[2] = ambiant;
	}
}

void Model::addLight(Light& light)
{
	// pour chaque face
	for (int i = 0; i < nbFaces; i++)
	{
		// pour chaque vertex de la face
		for (int j = 0; j < 3; j++)
		{
			// on calcul la lumiere
			Color c = light.computeLighting(vertex[faces[i].vertexIndex[j]],normals[faces[i].normalIndex[j]]);
			// et on l'addition avec la lumiere precedente
			faces[i].color[j].r += c.r;
			faces[i].color[j].g += c.g;
			faces[i].color[j].b += c.b;
		}
	}
}

void Model::render()
{
	glBegin(GL_TRIANGLES);
	// pour chaque face
	for(int i = 0;i < nbFaces; i++)
	{
		// pour chaque vertex de la face
		for (int j = 0; j < 3; j++)
		{
			// on recupere la couleur, les coordonnees de texture et la position
			Color &c = faces[i].color[j];
			TexCoord &tc = texCoords[faces[i].texCoordIndex[j]];
			Vecteur &v = vertex[faces[i].vertexIndex[j]];
			// et on les envoient à openGL
			glColor3f(c.r,c.g,c.b);
			glTexCoord2f(tc.u,tc.v);
			glVertex3f(v.x,v.y,v.z);
		}
	}
	glEnd();
}

class Light
{
private:
	float radius;
	Color color;
	Vecteur position;
public:
	Light(void);
	virtual ~Light(void);
	void setRadius(float r);
	float getRadius();
	void setColor(float r, float g, float b);
	Color getColor();
	void setPosition(float x, float y, float z);
	Vecteur getPosition();
	Color computeLighting(const Vecteur & position, const Vecteur & normal);
};

IV-3. Gestion de l'atténuation.

// on calcul le verteur allant du vertex à la lumiere.
Vecteur vertexToLight = this->position - position;
float attenuation = std::max<float>(0.0f,1.0f - (vertexToLight.getLength() / radius));

IV-4. Gestion de l'ombrage.

// on calcul le verteur allant du vertex a la lumiere.
Vecteur vertexToLight = this->position - position;
float attenuation = 1.0f - (vertexToLight.getLength() / radius);
// on normalise le vecteur
vertexToLight.normalise();
// on calcul le produit scalaire NdotL avec N = normal et L = vertexToLight
attenuation *= vertexToLight*normal;
attenuation = std::max<float>(0.0f,attenuation);

Color Light::computeLighting(const Vecteur & position, const Vecteur & normal)
{
	// on calcul le verteur allant du vertex à la lumiere.
	Vecteur vertexToLight = this->position - position;
	float attenuation = 1.0f - (vertexToLight.getLength() / radius);
	// on normalise le vecteur
	vertexToLight.normalise();
	// on calcul le produit scalaire
	attenuation *= vertexToLight*normal;
	attenuation = std::max<float>(0.0f,attenuation);
	Color ret = this->color;
	ret.r *= attenuation;
	ret.g *= attenuation;
	ret.b *= attenuation;
	return ret;
}

IV-5. Le rendu final

scene->initLighting(ambiant);
// on ajoute nos lumieres
scene->addLight(light1);
scene->addLight(light2);
// on active la texture
glEnable(GL_TEXTURE_2D);
// on affiche la scene
scene->render();

Scène éclairée par 3 lumières : 1 rouge, 1 bleu et 1 blanche

V. Conclusions.

Cas ou l'atténuation de l'éclairage par vertex pose problème

retour au menu.

Tutoriel 2 : light mapping simple.