Chapitre -100 · PBR

PBR Rendering — la lumière comme en vrai

Le fragment_Assimp du chapitre ↘ Assimp éclaire avec Blinn-Phong : un diffus, un reflet pow(NdotH, shininess) et une ambiance fixe à 0.3. Ça marche, mais chaque nombre est un réglage « à l'œil » : un shininess de 32, un reflet multiplié par 1 - roughness … Change le soleil ou la texture, et le matériau ne ressemble plus à rien.

Le Physically Based Rendering remplace ces réglages par un modèle tiré de la physique : la surface est faite de micro-facettes, elle ne renvoie jamais plus de lumière qu'elle n'en reçoit, et elle reflète davantage vue de biais. Résultat : un matériau décrit par trois valeurs — couleur, rugosité, métal — garde le même aspect sous n'importe quelle lumière. Ce sont exactement les trois textures que ton .glb fournit déjà.

Objectif de ce chapitreWhat you’ll learn
Wat je leert
  • Comprendre les micro-facettes et la conservation de l'énergie
  • Lire la BRDF de Cook-Torrance : D (GGX), F (Fresnel-Schlick), G (Smith)
  • Le workflow métal / rugosité du glTF : F0, albedo, kD
  • Écrire PBR.metal et le brancher dans fragment_Assimp
  • Comparer Blinn-Phong et PBR sur la même sphère
⏱ ~35 min
PrérequisPrerequisites
Vereisten

Les quatre vecteurs

Tout le PBR se joue autour d'un point de la surface et de quatre directions unitaires, toutes orientées vers l'extérieur :

N : la normale (après la normal map).

L : vers la lumière. Dans le moteur, sun.sunDirection pointe déjà vers le soleil.

V : vers la caméra, normalize(sun.cameraPosition.xyz - in.worldPos).

H : le half vector, à mi-chemin entre L et V : \( H = \frac{L + V}{\lVert L + V \rVert} \). Une micro-facette dont la normale vaut H renvoie exactement L vers V.

soleil caméra N L V H θl θv point de la surface
N · L = cos θl : la lumière reçue. N · V = cos θv : l'angle de vue. N · H : à quel point les micro-facettes « bien orientées » sont nombreuses.

Micro-facettes

À l'échelle du micromètre, aucune surface n'est plane. Le PBR la décrit comme une foule de minuscules miroirs, les micro-facettes, plus ou moins désordonnés. La rugosité (roughness, 0 → 1) mesure ce désordre :

roughness ≈ 0 : lisse reflet net et concentré roughness ≈ 1 : rugueux reflet large et diffus
Même lumière, même matériau : seule l'orientation des micro-facettes change. Le reflet s'élargit, et s'affaiblit d'autant — l'énergie totale ne bouge pas.

On ne dessine pas ces facettes : on décrit leur statistique. Pour un pixel, la question devient « quelle proportion des facettes est orientée selon H, donc renvoie le soleil vers la caméra ? ». C'est le rôle de la fonction D, plus bas.

Conservation de l'énergie

Quand la lumière touche la surface, elle se sépare en deux :

une part réfléchie tout de suite, sans changer de couleur pour un non-métal : le spéculaire ;

une part réfractée qui entre dans la matière, rebondit sur les pigments, et ressort un peu plus loin, teintée et dans toutes les directions : le diffus.

non-métal (plastique, bois, peau) F 1 − F reflet blanc (≈ 4 %) + diffus coloré métal (or, cuivre, fer) F ≈ albedo absorbé reflet coloré, aucun diffus
Ce qui est réfléchi (F) n'est plus disponible pour le diffus : kS + kD ≤ 1. Un métal absorbe tout ce qui entre : son diffus vaut zéro.

En code, ça donne deux coefficients : \( k_S = F \) pour le spéculaire, \( k_D = (1 - F)(1 - \text{metallic}) \) pour le diffus. L'ancien shader avait déjà le (1.0 - metallic), mais pas le (1 - F) : il pouvait renvoyer plus de lumière qu'il n'en recevait.

L'équation de réflectance

La couleur d'un pixel est la lumière \( L_o \) qui part du point vers la caméra. Pour la calculer, on additionne toute la lumière qui arrive sur la demi-sphère \( \Omega \) au-dessus de la surface, pondérée par la BRDF \( f_r \) et par l'angle d'arrivée :

\[ L_o(p, V) = \int_{\Omega} f_r(p, L, V)\; L_i(p, L)\; (N \cdot L)\; dL \]

Avec un seul soleil, toute la lumière arrive d'une seule direction : l'intégrale se réduit à un seul terme. Avec plusieurs lampes, une boucle qui additionne ce terme par lampe. L'intégrale complète ne revient que pour la lumière qui vient de partout — le ciel, l'ambiance — et c'est le sujet de l'IBL, à la fin du chapitre.

La BRDF de Cook-Torrance

La BRDF utilisée par Unreal, Unity, Blender (Principled BSDF) et le glTF est celle de Cook-Torrance : un diffus de Lambert plus un spéculaire à micro-facettes.

\[ f_r = k_D\,\frac{c}{\pi} \;+\; \frac{D \cdot F \cdot G}{4\,(N \cdot V)\,(N \cdot L)} \]

Le diffus \( \frac{c}{\pi} \) est la couleur \( c \) (l'albedo) divisée par \( \pi \) : intégrée sur la demi-sphère, une surface blanche renvoie alors exactement ce qu'elle reçoit, pas π fois plus. Le spéculaire est le produit de trois fonctions, une par question.

D — Distribution normale (Trowbridge-Reitz GGX)

Quelle proportion des micro-facettes est alignée sur H ? Lisse : presque toutes autour de N, d'où un pic très haut et très étroit. Rugueux : un dôme bas et large.

\[ D = \frac{\alpha^2}{\pi\,\big((N \cdot H)^2(\alpha^2 - 1) + 1\big)^2} \qquad \alpha = \text{roughness}^2 \]

Le carré \( \alpha = \text{roughness}^2 \) est une convention de Disney (2012) reprise partout, glTF compris : la rugosité que l'artiste règle dans Blender est perceptuelle, et l'élever au carré rend le curseur régulier à l'œil.

F — Fresnel (approximation de Schlick)

Regarde un lac : à tes pieds tu vois le fond, à l'horizon il reflète le ciel. Toute surface reflète plus quand on la regarde de biais. Schlick approche ce phénomène avec une seule valeur, \( F_0 \), le reflet vu de face :

\[ F = F_0 + (1 - F_0)\,\big(1 - (H \cdot V)\big)^5 \]

0 0.5 1 0° 30° 60° 90° angle entre H et V (0° = de face, 90° = rasant) F0 = 0.95 (argent) F0 = 0.56 (fer) F0 = 0.04 (plastique)
Un plastique ne reflète que 4 % de face, mais 100 % à l'horizon. Un métal reflète beaucoup sous tous les angles.

\( F_0 \) se mesure en laboratoire. Les non-métaux tournent tous autour de 0.04 en gris ; les métaux ont un \( F_0 \) fort et coloré — c'est leur couleur :

MatériauF0 (linéaire)
Eau(0.02, 0.02, 0.02)
Plastique, verre, bois, peau(0.04, 0.04, 0.04)
Fer(0.56, 0.57, 0.58)
Cuivre(0.95, 0.64, 0.54)
Or(1.00, 0.71, 0.29)
Aluminium(0.91, 0.92, 0.92)
Argent(0.95, 0.93, 0.88)

G — Géométrie (Smith, Schlick-GGX)

Sur une surface rugueuse, une facette bien orientée peut quand même être cachée par sa voisine : soit la lumière ne l'atteint pas (ombrage), soit la caméra ne la voit pas (masquage). G est la part des facettes qui reste visible des deux côtés.

ombrage : L bloquée facette dans l'ombre masquage : V bloquée facette cachée à la caméra
Plus la surface est rugueuse et plus l'angle est rasant, plus G est petit : c'est ce qui assombrit les bords d'une sphère rugueuse.

La méthode de Smith multiplie deux termes, un pour la lumière, un pour la caméra :

\[ G = G_1(N \cdot V)\;G_1(N \cdot L) \qquad G_1(x) = \frac{x}{x\,(1 - k) + k} \qquad k = \frac{(\text{roughness} + 1)^2}{8} \]

Ce \( k \) est celui d'Unreal (Brian Karis, 2013) pour une lumière directe. Pour l'IBL, on prendra \( k = \alpha^2 / 2 \) — même nom, autre valeur, LearnOpenGL fait la même distinction.

Le workflow métal / rugosité

Le glTF (et donc ton .glb) décrit un matériau avec trois textures, que fragment_Assimp lit déjà :

Toute la magie tient en une ligne : un non-métal a un \( F_0 \) de 0.04, un métal prend sa couleur comme \( F_0 \), et metallic passe de l'un à l'autre :

/// MSL — Exemple — update:28/10/26
float3 F0 = mix(float3(0.04), albedo.rgb, metallic);

C'était déjà le specularColor de l'ancien shader : Blinn-Phong n'était pas si loin, il lui manquait D, F et G.

Comparer sur une sphère

À gauche, le Blinn-Phong actuel de fragment_Assimp. À droite, le PBR de ce chapitre. Même albedo, même soleil, même ambiance 0.3, même tone mapping ACES. Joue avec la rugosité : à gauche le reflet change de forme sans logique, à droite il s'élargit et s'affaiblit en gardant la même énergie. Le menu « Afficher » isole chaque terme de la BRDF.

Avant : Blinn-Phong (fragment_Assimp)

Après : PBR Cook-Torrance

Le même albedo, rugosité de 0 à 1 — en haut non-métal, en bas métal (PBR)

Survole une sphère pour lire N·L, N·V, D, F, G et la couleur finale.

PBR.metal

Les quatre fonctions dans leur propre fichier, comme ToneMapping.metal : n'importe quel shader du moteur peut l'inclure. Elles sont static pour la même raison que les courbes de tone mapping : le Makefile compile aussi PBR.metal seul, et chaque fichier qui l'inclut en garde une copie privée — pas de symbole en double à l'édition des liens.

/// MSL — PBR.metal — update:28/10/26
#include <metal_stdlib>
using namespace metal;

// D — Trowbridge-Reitz GGX : la proportion de micro-facettes orientées selon H
static inline float distributionGGX(float3 N, float3 H, float roughness)
{
  float a = roughness * roughness; // α = roughness² (convention Disney / glTF)
  float a2 = a * a;
  float NdotH = max(dot(N, H), 0.0);
  float denom = (NdotH * NdotH) * (a2 - 1.0) + 1.0;
  denom = M_PI_F * denom * denom;
  return a2 / max(denom, 1e-12); // roughness 0 et N == H : denom = 0. Pas plus gros : π·a2² vaut 5e-11 à roughness 0.045
}

// G1 — Schlick-GGX, k de la lumière directe (Karis, 2013). Le dénominateur vaut au moins k > 0
static inline float geometrySchlickGGX(float NdotV, float roughness)
{
  float r = (roughness + 1.0);
  float k = (r * r) / 8.0;
  return NdotV / (NdotV * (1.0 - k) + k);
}

// G — Smith : ombrage (côté lumière) × masquage (côté caméra)
static inline float geometrySmith(float3 N, float3 V, float3 L, float roughness)
{
  float NdotV = max(dot(N, V), 0.0);
  float NdotL = max(dot(N, L), 0.0);
  return geometrySchlickGGX(NdotV, roughness) * geometrySchlickGGX(NdotL, roughness);
}

// F — Fresnel-Schlick : F0 de face, 1 à l'angle rasant
inline float3 fresnelSchlick(float cosTheta, float3 F0)
{
  return F0 + (1.0 - F0) * pow(saturate(1.0 - cosTheta), 5.0);
}

// F pour la lumière ambiante : une surface rugueuse ne monte pas jusqu'à 1 à l'angle rasant
inline float3 fresnelSchlickRoughness(float cosTheta, float3 F0, float roughness)
{
  return F0 + (max(float3(1.0 - roughness), F0) - F0) * pow(saturate(1.0 - cosTheta), 5.0);
}
Pourquoi saturate dans Fresnel ?

pow(x, 5.0) avec un x négatif n'est pas défini en MSL (NaN). cosTheta vient d'un produit scalaire de vecteurs unitaires : avec les arrondis, il peut valoir 1.0000001, et 1.0 - cosTheta devient négatif. saturate le ramène dans \( [0, 1] \) — un pixel noir ou blanc isolé sur un reflet, c'est souvent ça.

Brancher le PBR dans fragment_Assimp

Le début du shader ne bouge pas : mêmes textures, mêmes valeurs neutres quand une texture manque, même normal map. Seul l'éclairage, après la normale, est remplacé.

/// MSL — Exemple — update:28/10/26
#include "PBR.metal"

fragment float4 fragment_Assimp(VertexOut         in                [[stage_in]],
                                texture2d<float>  diffuseTexture    [[texture(0)]],
                                texture2d<float>  normalTexture     [[texture(1)]],
                                texture2d<float>  roughnessTexture  [[texture(2)]],
                                texture2d<float>  metallicTexture   [[texture(3)]],
                                sampler           textureSampler    [[sampler(0)]],
                                constant Sun&     sun               [[buffer(1)]])
{
    // Un modèle n'a pas toujours toutes ses textures : une texture non liée se lit comme nullptr,
    // is_null_texture() évite de l'échantillonner et donne une valeur neutre à la place.
    float4 albedo = is_null_texture(diffuseTexture) ? float4(1.0) : diffuseTexture.sample(textureSampler, in.texCoord);
    // glTF range rugosité et métal dans UNE image : rugosité en G, métal en B
    float roughness = is_null_texture(roughnessTexture) ? 0.5 : roughnessTexture.sample(textureSampler, in.texCoord).g;
    float metallic = is_null_texture(metallicTexture) ? 0.0 : metallicTexture.sample(textureSampler, in.texCoord).b;
    roughness = clamp(roughness, 0.045, 1.0); // sous 0.045, le pic de GGX est trop fin et trop haut (limite de Filament)

    float3 N = normalize(in.normal);
    if (!is_null_texture(normalTexture))
    {   // Normal map : une normale en espace tangent (T, B, N), encodée de [-1, 1] vers [0, 1]
        float3 T = normalize(in.tangent.xyz - dot(in.tangent.xyz, N) * N); // Gram-Schmidt : T bien perpendiculaire à N
        float3 B = cross(N, T) * in.tangent.w;
        float3 tangentNormal = normalTexture.sample(textureSampler, in.texCoord).rgb * 2.0 - 1.0;
        N = normalize(float3x3(T, B, N) * tangentNormal);
    }

    // Les quatre vecteurs partent de la surface
    float3 V = normalize(sun.cameraPosition.xyz - in.worldPos); // vers la caméra
    float3 L = normalize(sun.sunDirection.xyz);                 // vers le soleil
    float3 H = normalize(V + L);
    float NdotL = max(dot(N, L), 0.0);
    float NdotV = max(dot(N, V), 0.0001);                       // jamais 0 : il divise le spéculaire

    // Workflow métal / rugosité : 4 % de reflet pour un non-métal, sa couleur pour un métal
    float3 F0 = mix(float3(0.04), albedo.rgb, metallic);

    // Cook-Torrance : D · F · G / (4 · NdotV · NdotL)
    float  D = distributionGGX(N, H, roughness);
    float  G = geometrySmith(N, V, L, roughness);
    float3 F = fresnelSchlick(max(dot(H, V), 0.0), F0);
    float3 specular = (D * G * F) / (4.0 * NdotV * NdotL + 0.0001);

    // Ce qui est réfléchi n'entre pas dans la matière, et un métal absorbe tout ce qui y entre
    float3 kD = (1.0 - F) * (1.0 - metallic);

    // Le soleil du chapitre Couleurs vaut ≈ 1 ; × π compense le / π du diffus de Lambert
    float3 radiance = sun.sunColor.xyz * M_PI_F;
    float3 Lo = (kD * albedo.rgb / M_PI_F + specular) * radiance * NdotL;

    // Ambiance : un ciel gris uniforme de 0.3, en attendant l'IBL. Le Fresnel « rugueux » partage
    // cette lumière entre reflet et diffus, sinon un métal à l'ombre serait tout noir.
    float3 kSAmbient = fresnelSchlickRoughness(NdotV, F0, roughness);
    float3 kDAmbient = (1.0 - kSAmbient) * (1.0 - metallic);
    float3 ambient = (kDAmbient * albedo.rgb + kSAmbient) * 0.3;

    float3 finalColor = ambient + Lo;

    finalColor = ACESFitted(finalColor); // ou reinhard, hableFilmic, acesNarkowicz, lottes, agx, pbrNeutral
    return float4(finalColor, albedo.a);
}

Le π du soleil

LearnOpenGL éclaire avec des lampes d'intensité 300 et ne s'en soucie pas. Ici, le soleil de sunColorForAngle vaut environ 1, pensé pour Blinn-Phong. Divisé par π, un mur blanc ne recevrait plus que 32 % de la lumière d'avant : la scène s'assombrirait d'un coup. Multiplier la radiance par π, c'est dire « sunColor est l'éclairement d'une surface face au soleil » — la convention des moteurs qui expriment leurs lumières en lux. Un mur blanc face au soleil renvoie alors exactement sunColor, comme avant.

Les trois gardes

⬡CheckPoint Compilation — tes … en PBR

Plusieurs lumières

L'équation de réflectance est une somme : chaque lumière ajoute son propre Lo, calculé avec son L, son H et sa radiance. Pour une lampe ponctuelle, la radiance décroît avec le carré de la distance — c'est la boucle de LearnOpenGL :

/// MSL — Exemple — update:28/10/26
float3 Lo = float3(0.0);
for (uint i = 0; i < lightCount; ++i)
{
    float3 toLight = lights[i].position.xyz - in.worldPos;
    float  distance = length(toLight);
    float3 L = toLight / distance;
    float3 H = normalize(V + L);
    float3 radiance = lights[i].color.xyz / (distance * distance); // loi en 1 / d²

    float  NdotL = max(dot(N, L), 0.0);
    float  D = distributionGGX(N, H, roughness);
    float  G = geometrySmith(N, V, L, roughness);
    float3 F = fresnelSchlick(max(dot(H, V), 0.0), F0);
    float3 kD = (1.0 - F) * (1.0 - metallic);
    float3 specular = (D * G * F) / (4.0 * NdotV * NdotL + 0.0001);
    Lo += (kD * albedo.rgb / M_PI_F + specular) * radiance * NdotL;
}

Et ensuite : l'IBL

L'ambiance 0.3 est le dernier réglage « à l'œil » du shader. Dans la réalité, la lumière ambiante est le ciel lui-même — et tu en as déjà un, la ↘ Skybox. L'Image Based Lighting calcule l'intégrale complète de l'équation de réflectance sur cette cubemap : une carte d'irradiance pour le diffus, une cubemap pré-filtrée par rugosité et une petite texture 2D (la BRDF LUT) pour le spéculaire. C'est la suite de LearnOpenGL (Diffuse irradiance, Specular IBL), et c'est là que fresnelSchlickRoughness et le \( k = \alpha^2 / 2 \) de Smith serviront vraiment.