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

C'est, historiquement, le premier modèle d'éclairage en temps réel utilisé. En effet, l'éclairage en temps réel étant coûteux, lorsque les ordinateurs n'avaient pas de carte accélératrice, il fallait utiliser un système très rapide, même s'il présente les désavantages présentés précédemment.

C'est ce modèle dont nous allons étudier la mise en œuvre dans ce premier tutoriel.

Comme son nom l'indique (si vous n'êtes pas anglophobe), le light mapping consiste à stocker l'éclairage dans une texture. Cet algorithme se décompose en deux étapes :

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 finale obtenue est celle de la texture, donc une zone éclairée.

Cette technique a comme gros avantage de permettre de précalculer la texture d'éclairage pour les lumières statiques, et étant basé sur l'utilisation de textures, d'utiliser principalement les ressources de la carte graphique.

Le light mapping est à la base un système de gestion des lumières statiques, mais il est facile de lui ajouter une gestion de l'éclairage dynamique.
Cette méthode sera vue dans les tutoriels 2 et 3.

Basé sur des extensions comme le DOT3 bump mapping ou les shaders, l'éclairage par pixel est possible de nos jours, car les cartes graphiques ayant évolué, le développeur peut maintenant intervenir sur la façon dont sont calculés les pixels avant qu'ils ne soient ajoutés à la scène. Cette méthode de gestion de l'éclairage permet un très bon rendu graphique, tout en étant très flexible. Le choix peut donc être fait entre la qualité graphique ou la performance, en implémentant seulement une partie d'un modèle d'éclairage par exemple.

Cette méthode permettant de nombreuses implémentations, nous l'étudierons durant trois tutoriels.

Il existe d'autres méthodes (qui sont généralement calculées par pixel) comme les spherical harmonics par exemple, mais ces techniques étant plus anecdotiques dans l'industrie 3D, nous ne les étudierons pas ici.

L'éclairage par vertex consiste simplement à effectuer l'ensemble des calculs d'éclairage au niveau des vertex. Ce système est très simple et peut se résumer à l'algorithme en pseudocode suivant :

initialiser la luminosité de tous les vertex à la lumière ambiante
pour chaque lumière
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

L'algorithme peut être simplifié en ne prenant pas en compte les vertex des faces, mais directement la géométrie, mais cela a pour conséquence de ne pas pouvoir avoir de vertex à normales multiples.

Un vertex à normales multiples est un point de l'espace qui est partagé entre plusieurs faces ayant des orientations très différentes. Par exemple un cube a huit vertex, mais ses faces ont des orientations suffisamment différentes pour qu'on ne souhaite pas lisser les normales de ces vertex (on parle de normal smoothing), le vertex aura alors plusieurs normales (dans le cas du cube, une par face qui utilise le vertex). Généralement la gestion des normales lissées est laissée à la discrétion de l'artiste qui crée la scène via un outil de modélisation. Ici, nous utiliserons donc les normales contenues dans le fichier.

Pour commencer l'étude de la mise en œuvre, nous allons voir la structure de données utilisée par nos calculs, ensuite nous aborderons le problème du calcul de l'atténuation de la luminosité, et pour finir, nous parlerons de l'ombrage.

Nous ne traiterons pas des composantes spéculaire et émissive de la lumière, mais leur implémentation est relativement facile à mettre en place.

Ici, nous allons parler des structures de données utilisées pour le calcul de la luminosité de la scène. J'utilise dans ce tutoriel des classes basiques pour gérer mes vecteurs, couleurs et coordonnées de textures. Ces classes ne seront pas détaillées ici, mais elles sont disponibles avec le code.

Pour le tutoriel nous utilisons une scène stockée dans un fichier .obj. Le chargement de ce fichier n'entre pas en compte dans ce tutoriel, mais il nous permet de récupérer les informations de géométrie sous la forme de quatre tableaux qui contiennent :

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

Les faces sont des structures qui contiennent les indices des vertex/normales/coordonnées de texture de chacun des points de la face. Ici nous ne traitons que des faces triangulaires.
Nous avons donc besoin d'une structure pour stocker ces faces

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

Ici, la face contient aussi une couleur pour chacun de ses vertex, c'est la couleur qui sera utilisée pour déterminer l'éclairage final du vertex. Cette information est propre à ce tutoriel et disparaîtra dans les tutoriels suivants.

Nous avons besoin d'une classe qui va gérer notre géométrie. Cette classe doit pouvoir stocker les informations sur les vertex, normales, coordonnées de texture et sur les faces. Elle doit aussi permettre de charger un fichier de géométrie, gérer l'éclairage et le rendu de la scène.

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();
};

La méthode load() sert à charger la géométrie depuis un fichier, elle n'est pas particulièrement intéressante ici, la seule information qui nous intéresse est que le chargement prend en compte les normales partagées, nous avons donc un modèle dont certains vertex ont plusieurs normales et donc un rendu cohérent des cubes et autres formes avec des angles importants entre les faces.

La méthode initLighting prend en paramètre la couleur ambiante et l'assigne à tous les vertex de la scène. Cette méthode donne donc :

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;
    }
}

La méthode addLight prend en paramètre une lumière, effectue les calculs d'éclairage et les applique aux vertex. Le code donne donc :

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 calcule la lumière
            Color c = light.computeLighting(vertex[faces[i].vertexIndex[j]],normals[faces[i].normalIndex[j]]);
            // et on l'additionne avec la lumière précédente
            faces[i].color[j].r += c.r;
            faces[i].color[j].g += c.g;
            faces[i].color[j].b += c.b;
        }
    }
}

Avec computeLighting, la fonction de calcul de la luminosité du vertex. Cette méthode sera vue plus loin.

Ici la luminosité calculée est additionnée à celle calculée précédemment, car, comme nous l'avons vu, la lumière est additive.

Il ne nous reste plus que la méthode permettant le rendu de la scène. Elle est relativement simple, et ici, je n'utilise aucune optimisation à base de tableaux de vertex ou autre, j'effectue un simple rendu en mode immédiat.

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 récupère la couleur, les coordonnées 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 envoie à openGL
            glColor3f(c.r,c.g,c.b);
            glTexCoord2f(tc.u,tc.v);
            glVertex3f(v.x,v.y,v.z);
        }
    }
    glEnd();
}

Maintenant que nous avons notre classe de gestion de la géométrie, nous avons besoin d'une classe qui gère une lumière.

Pour nous simplifier la gestion des calculs, c'est cette classe qui va calculer l'éclairage des vertex en fonction de leur position et de leur normale.

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);
};

Notre lumière contient simplement une position, un rayon et une couleur. Mis à part les accesseur et modificateur, cette classe ne contient qu'une méthode intéressante : computeLighting qui prend en paramètre la position d'un vertex et sa normale et retourne sa couleur d'éclairage. C'est cette méthode qui permet de calculer l'éclairage du vertex comme nous allons le voir.

La première chose à prendre en compte dans notre calcul de la luminosité est l'atténuation de la lumière. En effet plus notre vertex est loin de la lumière, moins il est éclairé, et s'il dépasse le rayon d'action de la lumière, il n'est plus du tout éclairé.

Il existe plusieurs équations pour calculer l'atténuation (linéaire, quadratique et autres). Ici, nous utiliserons une équation linéaire. C'est-à-dire qu'un vertex situé à mi-distance du rayon de la lumière recevra la moitié de sa luminosité.
L'équation donne donc

atténuation = max ( 0, 1-(distance / rayon))

où atténuation est le facteur d'atténuation de la lumière en fonction de la distance, distance est la distance du vertex par rapport à la position de la lumière et rayon est le rayon maximum de la lumière.

Le code du calcul de l'atténuation donne donc :

// on calcule le vecteur allant du vertex à la lumière.
Vecteur vertexToLight = this->position - position;
float attenuation = std::max<float>(0.0f,1.0f - (vertexToLight.getLength() / radius));

Nous calculons le vecteur allant du vertex à la lumière. Ici, le sens du vecteur n'a pas d'importance étant donné que ce qui nous intéresse est sa longueur, mais il est néanmoins important de le calculer dans le bon sens, car il est réutilisé par la suite dans la gestion de l'ombrage.

Ce qui est appelé ombrage en infographie est à différencier des ombres portées. L'ombre portée correspond à l'ombre générée par un objet sur un autre objet. L'ombrage lui est juste le fait qu'une face est moins éclairée si elle ne fait pas face à la lumière et est complètement ombrée si elle tourne le dos à la lumière.

Nous voulons donc obtenir ce comportement pour nos vertex. Pour cela, nous allons justement utiliser le fameux calcul NdotL. Mais d'abord un petit rappel de maths sur le produit scalaire s'impose.

Le produit scalaire entre deux vecteurs normalisés (de longueur 1) a une propriété intéressante.

Si les deux vecteurs sont identiques, le produit scalaire vaut 1. Si les deux vecteurs ont la même direction, le produit scalaire est compris dans ]0..1]. Si les deux vecteurs sont perpendiculaires, le produit scalaire vaut 0, s'ils sont de sens opposés, le produit scalaire est compris dans [-1..0[, et s'ils sont complètement opposés, le produit scalaire vaut -1.

Appliqué à notre problème, si le produit scalaire entre la normale et le vecteur vertexToLight est supérieur à 0, c'est que la face est éclairée, sinon, elle est dans l'ombre. Et, encore plus intéressant, si la normale est exactement identique au vecteur vertexToLight (c'est-à-dire si le polygone fait exactement face à la lumière), le produit scalaire vaut 1. Nous avons donc, à moindre coût, le calcul exact de l'ombrage de nos faces avec un simple produit scalaire (et une normalisation de vecteur, car il faut que le vecteur vertexToLight soit normalisé pour que ce calcul fonctionne). Nous avons donc retrouvé notre NdotL, mais nous l'appliquons par vertex et non par faces.

Notre fonction de calcul de la luminosité devient donc :

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

Maintenant que nous avons calculé la luminosité de notre vertex, nous devons calculer sa couleur. Ceci se fait simplement en multipliant la couleur de la lumière par la luminosité du vertex. Nous obtenons donc le code final de la méthode computeLighting :

Color Light::computeLighting(const Vecteur & position, const Vecteur & normal)
{
    // on calcule le vecteur allant du vertex à la lumière.
    Vecteur vertexToLight = this->position - position;
    float attenuation = 1.0f - (vertexToLight.getLength() / radius);
    // on normalise le vecteur
    vertexToLight.normalise();
    // on calcule 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;
}

Maintenant que nous avons tout ce qu'il faut pour calculer notre éclairage, il nous faut l'afficher. Ceci se fait très simplement en respectant la séquence suivante :

scene->initLighting(ambiant);
// on ajoute nos lumières
scene->addLight(light1);
scene->addLight(light2);
// on active la texture
glEnable(GL_TEXTURE_2D);
// on affiche la scène
scene->render();

Ce qui donne le résultat suivant :