Article Index

Les différents type de lights

https://docs.unrealengine.com/Images/Engine/Rendering/LightingAndShadows/Basics/LI_Sprites.webp

Les lumières, sous forme de "nodes", exercent leur influence sur les objets 3D, comme nous l'avons vu précédemment. En informatique, elles peuvent être classées en deux grandes catégories :

1. Lumières Ambiantes:

Une lumière ambiante, comme rappelé précédemment, est si dispersée qu'elle perd toute directionnalité et source identifiable. Elle illumine chaque point de la scène avec une intensité uniforme. Définie par sa couleur et son intensité, elle ne contribue à aucune réflexion spéculaire et agit indépendamment des autres lumières présentes dans la scène. En termes de calculs, c'est la moins coûteuse parmi tous les types de lumières.

2. Lumières directionnelles:

Comme leur nom l'indique, les lumières directionnelles possèdent une direction en plus d'une couleur et d'une intensité. Cette direction est définie par la distance entre le point d'origine et la position actuelle de la lumière. On distingue trois types de lumières directionnelles, détaillées dans les sous-chapitres suivants :
Point
Une lumière ponctuelle n'a pas de direction spécifique et éclaire de manière uniforme dans toutes les directions. Un feu de camp ou une ampoule en sont des exemples typiques. Ces lumières sont plus coûteuses que les lumières directionnelles. Contrairement à ces dernières, une lumière ponctuelle est sujette à l'atténuation (l'intensité lumineuse diminue avec la distance) et a une portée d'éclairage (au-delà de laquelle la lumière cesse d'éclairer).
 
https://docs.unrealengine.com/Images/Resources/ContentExamples/Lighting/1_1/LightRadius_PointLight.webp
vec3 pointLightDirection(Light light, vec3 position) {
    return normalize(light.point.position - position);
}
float pointLightAttenuation(Light light, vec3 position) {
    float d = length(light.point.position - position);
    float attenuation = light.point.attenuation.constant +
                        light.point.attenuation.linear * d +
                        light.point.attenuation.quadratic * d * d;
    return 1 / attenuation;
}
Directionelle
Une lumière directionnelle est une source lumineuse qui ne possède pas de position spécifique et émet une lumière qui se propage en ligne droite à travers la scène. Dans les jeux, elle est fréquemment employée pour simuler la lumière du soleil ou de la lune. Bien qu'elle ne soit pas très coûteuse en termes de performances, il est conseillé de l'utiliser avec modération afin de prévenir toute réduction notable du nombre d'images par seconde (FPS) dans le jeu.
 
http://irrlicht-fr.org/_imagesT/img_22.jpg
vec3 directionalLightDirection(Light light, vec3 position) {
    return -light.directional.direction;
}
float directionalLightAttenuation(Light light, vec3 position) {
    return 1.0f;
}
Spot
Une lumière spot peut être comparée à une torche électrique ou aux phares d'une automobile. C'est la source lumineuse la plus complexe à mettre en œuvre et la plus exigeante en termes de calcul. Elle possède à la fois une direction et une position définies. L'intensité de la lumière est répartie entre deux cônes distincts : le cône intérieur et le cône extérieur. La lumière est plus intense dans le cône intérieur que dans le cône extérieur. Seuls les objets situés à l'intérieur de l'un de ces cônes sont éclairés. En plus de la position, de la direction, de l'atténuation et de la portée lumineuse, vous devez également définir la taille des cônes et la manière dont ils se chevauchent.
 
vec3 spotLightDirection(Light light, vec3 position) {
    return normalize(light.spot.position - position);
}
float spotLightAttenuation(Light light, vec3 position) {
    vec3 dir = normalize(light.spot.direction);
    float d = length(light.spot.direction);
    
    float attenuation = light.spot.attenuation.constant +
                        light.spot.attenuation.linear * d +
                        light.spot.attenuation.quadratic * d * d;
                        
    vec3 l = normalize(light.spot.position - position);
    float cosRealAngle = dot(l, dir);
    float cosSpotOuter = cos(light.spot.innerAngle / 2.0);
    float radialAttenuation = pow(clamp((cosRealAngle - cosSpotOuter) / (1.0 - cosSpotOuter), 0.0, 1.0), 1.6);
    return radialAttenuation / attenuation;
}