Optimiser le shader de la nébuleuse : de 9 ms à 2,1 ms par image
La nébuleuse rouge qui entoure Tau-Héliade est l'image la plus reconnaissable de Vesper Protocol. Elle coûtait aussi 9 millisecondes par image à elle seule. Voici les quatre optimisations qui ont permis à Flexarion de la ramener à 2,1 ms sans perdre son allure.
Le point de départ : un raymarching volumétrique naïf
Notre nébuleuse est un volume, pas une texture plaquée sur le ciel. Pour chaque pixel, le shader avance pas à pas le long du rayon de vue (raymarching), échantillonne une densité calculée à partir de bruit procédural, et accumule la lumière absorbée et diffusée.
La première version faisait 128 pas par pixel, avec 5 octaves de bruit calculées à chaque pas. Sur notre machine de référence — un portable avec une GeForce GTX 1650 en 1080p — elle prenait 9,0 ms : plus de la moitié de notre budget de 16,6 ms pour tenir 60 images par seconde.
Étape 1 : précalculer le bruit dans une texture 3D (9,0 → 5,2 ms)
Le bruit procédural était recalculé à chaque pas, pour chaque pixel. Or la forme de la nébuleuse change lentement. Nous générons maintenant le bruit une seule fois au chargement, dans une texture 3D de 128³ texels qui boucle sur elle-même. Le shader se contente d'y lire une valeur, et le matériel graphique s'occupe de l'interpolation. Pour garder du détail, nous ajoutons une seule octave de bruit calculée à la volée.
Étape 2 : moins de pas, mais mieux répartis (5,2 → 3,4 ms)
Passer de 128 à 48 pas faisait apparaître des bandes visibles dans le volume. La solution : décaler le point de départ de chaque rayon avec un bruit bleu. Les bandes deviennent un grain fin et régulier, que l'œil remarque beaucoup moins.
float jitter = texture(blueNoise, gl_FragCoord.xy / 64.0).r;
float t = tStart + jitter * stepSize;
for (int i = 0; i < 48; i++) {
float d = sampleDensity(rayOrigin + rayDir * t);
if (d > 0.01) accumulate(d, t);
if (transmittance < 0.02) break; // sortie anticipée
t += stepSize;
}
Nous avons aussi ajouté une sortie anticipée : quand le volume est déjà presque opaque, inutile de continuer à avancer.
Étape 3 : rendre à demi-résolution (3,4 → 2,4 ms)
Une nébuleuse est floue par nature. Nous la calculons donc à la moitié de la résolution de l'écran, puis nous l'agrandissons avec un suréchantillonnage bilatéral qui respecte les contours des objets au premier plan (vaisseaux, structure de la Vesper). Sans ce filtre, un halo apparaissait autour des silhouettes.
Étape 4 : la reprojection temporelle (2,4 → 2,1 ms)
Le grain du bruit bleu change à chaque image. En mélangeant l'image courante avec la précédente, reprojetée selon le mouvement de la caméra, ce grain se lisse dans le temps. Cela nous a permis de descendre encore à 40 pas tout en obtenant une image plus propre qu'au départ.
Bilan des optimisations
| Étape | Temps GPU |
|---|---|
| Version naïve (128 pas, bruit procédural) | 9,0 ms |
| Bruit précalculé en texture 3D | 5,2 ms |
| 48 pas + bruit bleu + sortie anticipée | 3,4 ms |
| Demi-résolution + suréchantillonnage bilatéral | 2,4 ms |
| Reprojection temporelle (40 pas) | 2,1 ms |
Ce que nous retenons
- Mesurer avant d'optimiser : sans profileur GPU, nous aurions optimisé la mauvaise partie.
- Exploiter ce que l'œil ne voit pas : un effet flou n'a pas besoin de la pleine résolution.
- Échanger du bruit contre du temps : bruit bleu et accumulation temporelle font le travail à notre place.
Ces gains libèrent du budget pour l'éclairage des intérieurs de la Vesper. Découvrez où cette nébuleuse apparaît dans le jeu sur la page Vesper Protocol, relisez le devlog précédent sur l'IA des Gardiens, reprenez les bases avec notre tutoriel de raymarching d'une nébuleuse, ou retrouvez tous les articles du devlog Flexarion.