Tutoriel Vulkan complet

Le composant central du développement d'applications Vulkan est le SDK. Il inclut les fichiers d’en-têtes, les couches de validation standards, des outils de débogage et un chargeur pour les fonctions Vulkan. Ce chargeur récupère, à l’exécution, les fonctions exposées par le pilote, comme le ferait GLEW pour OpenGL.

Le SDK peut être téléchargé sur le site de LunarG en utilisant les boutons en bas de page. Vous n'avez pas besoin de compte, mais celui-ci vous donne accès à une documentation supplémentaire qui pourra vous être utile.

Réalisez l'installation et notez l'emplacement du SDK. La première chose que nous allons faire est de vérifier si votre carte graphique supporte Vulkan. Allez dans le dossier d'installation du SDK, ouvrez le dossier Bin et lancez vkcube.exe. Vous devriez voir la fenêtre suivante :

Si vous recevez un message d'erreur, assurez-vous que votre pilote graphique est à jour, qu’il inclut Vulkan et que votre carte graphique est supportée. Référez-vous au chapitre introductifIntroduction pour les liens vers les principaux constructeurs.

Il y a d'autres programmes utiles pour le développement dans ce dossier : glslangValidator.exe et glslc.exe. Nous en aurons besoin pour la compilation des shaders. Ils transforment un code facilement compréhensible et semblable au C (le GLSL) en code intermédiaire (bytecode). Nous couvrirons cela dans le chapitre des modules shader. Le dossier Bin contient aussi les fichiers binaires du loader Vulkan et des couches de validation. Le dossier Lib contient les bibliothèques.

Enfin, le dossier Include contient les fichiers d’en-têtes de Vulkan. Vous pouvez parcourir les autres fichiers, mais nous ne les utiliserons pas dans ce tutoriel.

Comme dit précédemment, Vulkan ignore la plateforme sur laquelle il opère, et n'inclut pas d'outil de création de fenêtres où afficher notre rendu. Pour bien exploiter les possibilités multiplateformes de Vulkan et éviter les horreurs de Win32, nous utiliserons la bibliothèque GLFW pour créer une fenêtre, et ce, sur Windows, Linux ou MacOS. Il existe d'autres bibliothèques telles que SDL, mais GLFW a l'avantage d'abstraire d'autres aspects spécifiques à la plateforme requis par Vulkan.

Vous pouvez trouver la dernière version de GLFW sur leur site officiel. Nous utiliserons la version 64 bits, mais vous pouvez également utiliser la version 32 bits. Dans ce cas, assurez-vous de bien lier le dossier "Lib32" dans le SDK et non "Lib". Après avoir téléchargé GLFW, extrayez l'archive à l'emplacement qui vous convient. J'ai choisi de créer un dossier "Librairies" dans le dossier de Visual Studio (dans Mes Documents).

Contrairement à DirectX 12, Vulkan n'intègre pas de bibliothèque pour l'algèbre linéaire. Nous devons donc en télécharger une. GLM est une bonne bibliothèque conçue pour être utilisée avec les bibliothèques graphiques et est souvent utilisée avec OpenGL.

GLM est une bibliothèque écrite exclusivement dans les fichiers d’en-têtes. Il suffit donc d'en télécharger la dernière version, la stocker où vous le souhaitez et l'inclure là où vous en aurez besoin. Vous devez maintenant obtenir une structure semblable :

Maintenant que vous avez installé toutes les dépendances, nous pouvons préparer un projet Visual Studio pour Vulkan et écrire un peu de code pour vérifier que tout fonctionne.

Lancez Visual Studio et créez un nouveau projet Windows Desktop Wizard, entrez un nom et appuyez sur OK.

Assurez-vous que Console Application (.exe) est sélectionné comme type d'application afin que nous ayons un endroit où afficher nos messages d'erreurs et cochez Empty Project afin que Visual Studio ne génère pas un code de base.

Appuyez sur OK pour créer le projet et ajoutez un fichier source C++. Vous devriez déjà savoir faire ça, mais les étapes sont tout de même incluses ici.

Ajoutez maintenant le code suivant à votre fichier. Ne cherchez pas à le comprendre pour le moment, il sert juste à s'assurer que vous pouvez compiler et lancer une application Vulkan. Nous recommencerons tout depuis le début dès le chapitre suivant.

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supported\n";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Configurons maintenant le projet afin de nous débarrasser des erreurs. Ouvrez les propriétés du projet et assurez-vous que « Toutes les configurations » (All Configurations) soit sélectionné, car la plupart des paramètres s'appliquent autant dans le mode Debug que dans le mode Release.

Allez à C++ → General → Autres répertoires Include et cliquez sur <Modifier...> dans le menu déroulant.

Ajoutez les dossiers contenant les fichiers d’en-têtes de Vulkan, GLFW et GLM :

Ensuite, ouvrez l'éditeur pour les dossiers des bibliothèques sous Éditeur de liens → General :

Et ajoutez les emplacements des fichiers objet pour Vulkan et GLFW :

Allez à Linker → Entrée et cliquez sur <Modifier...> dans le menu déroulant de l’entrée Dépendances supplémentaires (Additional Dependencies) :

Entrez les noms des fichiers objet GLFW et Vulkan :

Finalement, activez le support des fonctionnalités du C++17 :

Vous pouvez enfin fermer la fenêtre des propriétés. Si vous avez tout fait correctement, vous ne devriez plus voir d'erreur dans votre code.

Finalement, assurez-vous que vous compilez effectivement en 64 bits :

Appuyez sur F5 pour compiler et lancer le projet. Vous devriez voir une fenêtre s'afficher comme cela :

Si le nombre d'extensions est nul, il y a un problème avec la configuration de Vulkan sur votre système. Sinon, vous êtes fin prêt à vous lancer avec VulkanDessiner un triangle !

Les composants les plus importants pour le développement d’applications Vulkan sous Linux sont le chargeur Vulkan, les couches de validations et quelques outils en ligne de commande pour tester si votre machine est capable d’exécuter une application Vulkan :

• sudo apt install vulkan-tools : installe les outils en ligne de commande, plus précisément vulkaninfo et vkcube. Lancez-les pour savoir si votre machine peut exécuter des applications Vulkan ;
• sudo apt install libvulkan-dev : installe le chargeur Vulkan. Il permet de récupérer les fonctions Vulkan auprès du pilote du GPU, de la même façon que peut le faire GLEW pour OpenGL ;
• sudo apt install vulkan-validationlayers-dev : installe les couches de validation standards. Celles-ci sont cruciales pour déboguer votre application Vulkan. Nous en reparlerons dans le prochain chapitre.

Si l’installation a réussi, vous devriez être prêt en ce qui concerne Vulkan. N’oubliez pas de lancer vkcube, qui devrait vous afficher la fenêtre suivante :

Comme dit précédemment, Vulkan ignore la plateforme sur laquelle il opère, et n'inclut pas d'outil de création de fenêtres où afficher notre rendu. Pour bien exploiter les possibilités multiplateformes de Vulkan, nous utiliserons la bibliothèque GLFW pour créer une fenêtre sur Windows, Linux ou MacOS. Il existe d'autres bibliothèques telles que SDL, mais GLFW a l'avantage d'abstraire d'autres aspects spécifiques à la plateforme requis par Vulkan.

Nous allons installer la bibliothèque GLFW grâce à la commande suivante :

sudo apt install libglfw3-dev

III-B-2-a. GLM▲

sudo apt install libglm-dev

Nous avons presque tout le nécessaire, sauf un programme pour compiler les shaders en GLSL, un langage compréhensible par les humains, vers du bytecode.

Il existe deux compilateurs de shader populaires : glsllangValidator de Khronos et glslc de Google. Ce dernier s’utilise d’une façon similaire à GCC et Clang et c’est pourquoi nous allons l’utiliser. Téléchargez les exécutables non officiels et copiez le fichier glslc dans votre répertoire /usr/local/bin. Notez que vous devrez certainement utiliser sudo en fonction de vos permissions. Pour tester, tapez la commande glslc dans un terminal : celui-ci devrait vous retourner le message suivant, stipulant que vous ne lui avez pas spécifié de shader à compiler :

glslc: error: no input files

Nous couvrirons l’utilisation de glslc plus en détail dans le chapitre des modules shadersModule de shaders.

Maintenant que vous avez installé toutes les dépendances, nous pouvons préparer un Makefile basique pour Vulkan et écrire un code très simple pour s'assurer que tout fonctionne correctement.

Créez un nouveau dossier là où cela vous plaît et nommez-le VulkanTest. Créez un fichier main.cpp et insérez-y le code suivant. Ne cherchez pas à le comprendre maintenant : il sert juste à s'assurer que vous pouvez compiler et exécuter une application Vulkan. Nous recommencerons tout depuis le début dès le chapitre suivant.

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supported\n";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Nous allons maintenant créer un Makefile pour compiler et lancer ce code. Créez un fichier Makefile. Je pars du principe que vous connaissez déjà les Makefiles, notamment le fonctionnement des variables et des règles. Sinon vous pouvez trouver des introductions claires sur internet, par exemple ici.

Nous allons d'abord définir quelques variables pour simplifier le reste du fichier. Définissez la variable CFLAGS qui spécifiera les options de base du compilateur :

CFLAGS = -std=c++17 -O2

Nous utiliserons du C++ moderne (-std=c++17) et nous activons les optimisations avec -O2. Vous pouvez retirer cette option pour compiler les programmes plus rapidement, mais n’oubliez pas de le remettre pour compiler des exécutables pour la production.

Définissez de manière analogue la variable LDFLAGS :

LDFLAGS = -lglfw -lvulkan -ldl -lpthread -lX11 -lXxf86vm -lXrandr -lXi

L’option -lglfw est pour la bibliothèque GLFW. L’option -lvulkan correspond au chargeur dynamique des fonctions Vulkan. Les autres options sont nécessaires pour GLFW et correspondent à des bibliothèques bas niveau pour la gestion des threads et des fenêtres.

La spécification de la règle pour la compilation de VulkanTest est désormais un jeu d'enfant. Assurez-vous que vous utilisez des tabulations et non des espaces pour l'indentation.

VulkanTest: main.cpp
    g++ $(CFLAGS) -o VulkanTest main.cpp $(LDFLAGS)

Vérifiez que cette règle fonctionne en sauvegardant le fichier et en exécutant make depuis un terminal ouvert dans le dossier contenant les fichiers main.cpp et Makefile. Vous devriez avoir un exécutable appelé VulkanTest.

Nous allons ensuite définir deux règles, test et clean. La première exécutera le programme et le second supprimera l'exécutable :

.PHONY: test clean

test: VulkanTest
    ./VulkanTest

clean:
    rm -f VulkanTest

La commande make clean provoque l’exécution du programme. Celui-ci affiche le nombre d’extensions Vulkan disponible ainsi qu’une fenêtre vide. L’application doit retourner le code de retour 0 (succès) quand vous fermez la fenêtre.

Vous devriez désormais avoir un Makefile ressemblant à ceci :

CFLAGS = -std=c++17 -O2
LDFLAGS = -lglfw -lvulkan -ldl -lpthread -lX11 -lXxf86vm -lXrandr -lXi

VulkanTest: main.cpp
    g++ $(CFLAGS) -o VulkanTest main.cpp $(LDFLAGS)

.PHONY: test clean

test: VulkanTest
    ./VulkanTest

clean:
    rm -f VulkanTest

Vous pouvez désormais utiliser ce dossier comme base pour vos projets Vulkan. Faites-en une copie, renommez-le en HelloTriangle et videz le fichier main.cpp.

Bravo, vous êtes fin prêt à vous lancer avec VulkanDessiner un triangle!

Le composant central du développement d'applications Vulkan est le SDK. Il inclut les fichiers d’en-têtes, les couches de validation standards, des outils de débogage et un chargeur pour les fonctions Vulkan. Ce chargeur récupère les fonctions exposées par le pilote à l'exécution, comme GLEW pour OpenGL, si cela vous parle.

Le SDK peut être téléchargé sur le site de LunarG en utilisant les boutons en bas de page. Vous n'avez pas besoin de compte, mais celui-ci vous donne accès à une documentation supplémentaire qui pourra vous être utile.

La version MacOS du SDK utilise MoltenVK. Il n'y a pas de support natif pour Vulkan sur MacOS, donc nous avons besoin de MoltenVK pour transcrire les appels aux fonctions Vulkan en appels au framework d’Apple : Metal. Grâce à cela, vous pouvez tirer avantage des performances et du débogage du framework Metal.

Une fois téléchargé, extrayez-en le contenu où vous le souhaitez (gardez en tête l’emplacement, car vous devez pointer ce dossier dans les projets Xcode). Dans le dossier extrait, le sous-dossier Applications comporte quelques exécutables de démonstration du SDK. Lancez vkcube pour vérifier que vous obtenez ceci :

Comme dit précédemment, Vulkan ignore la plateforme sur laquelle il opère, et n'inclut pas d'outil de création de fenêtres où afficher notre rendu. Pour bien exploiter les possibilités multiplateformes de Vulkan, nous utiliserons la bibliothèque GLFW pour créer une fenêtre qui supportera Windows, Linux et MacOS. Il existe d'autres bibliothèques telles que SDL, mais GLFW à l'avantage d'abstraire d'autres aspects spécifiques à la plateforme requis par Vulkan.

Pour installer GLFW, nous utiliserons le gestionnaire de package Homebrew. Le support de Vulkan sur MacOS n'étant pas parfaitement disponible (à l'écriture du moins) sur la version 3.2.1, nous installerons le package glfw3 ainsi :

brew install glfw3 --HEAD

Vulkan n'inclut aucune bibliothèque pour l'algèbre linéaire, nous devons donc en télécharger une. GLM est une bonne bibliothèque souvent utilisée avec les bibliothèques graphiques dont OpenGL.

Cette bibliothèque est intégralement codée dans les fichiers d’en-têtes et se télécharge avec le paquet glm :

brew install glm

Maintenant que nous avons toutes les dépendances, nous pouvons créer dans Xcode un projet Vulkan basique. La plupart des opérations seront de la « tuyauterie » pour lier les dépendances au projet. Notez que vous devrez remplacer toutes les mentions au dossier vulkansdk par le dossier où vous avez extrait le SDK Vulkan.

Lancez Xcode et créez un nouveau projet. Sur la fenêtre qui s'ouvre, sélectionnez Application → Command Line Tool.

Sélectionnez Next, inscrivez un nom de projet et choisissez C++ comme Language.

Appuyez sur Next et le projet devrait être créé. Copiez le code suivant à la place du code généré dans le fichier main.cpp :

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supported\n";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Gardez à l'esprit que vous n'avez pas à comprendre ce code pour le moment, sachant qu’il se contente d'appeler quelques fonctions de la bibliothèque pour s'assurer que tout fonctionne.

Xcode devrait déjà vous afficher des erreurs à propos de bibliothèques introuvables. Nous allons maintenant configurer le projet pour les faire disparaître. Sélectionnez votre projet sur le menu Project Navigator. Ouvrez l’onglet Build Settings puis :

• trouvez le champ Header Search Paths et ajoutez le chemin /usr/local/include (c'est ici que Homebrew installe les fichiers d’en-têtes) et le chemin vulkansdk/macOS/include pour le SDK ;
• trouvez le champ Library Search Paths et ajoutez le chemin /usr/local/lib (encore une fois, c’est le dossier où Homebrew installe les bibliothèques) et le chemin vulkansdk/macOS/lib.

Vous avez normalement (avec des différences évidentes selon l'endroit où vous avez placé votre SDK) :

Maintenant, dans l’onglet Build Phases, sur l’entrée Link Binary With Libraries ajoutez les frameworks glfw3 et vulkan. Pour nous simplifier les choses, nous allons ajouter les bibliothèques dynamiques directement dans le projet (référez-vous à la documentation de ces bibliothèques si vous voulez les lier de manière statique).

• Pour GLFW ouvrez le dossier /usr/local/lib où vous trouverez un fichier avec un nom comme libglfw.3.x.dylib (où x est le numéro de la version. Il peut être différent chez vous). Glissez ce fichier jusqu'à l’onglet « Linked Frameworks and Librairies » de Xcode.
• Pour Vulkan, rendez-vous dans le dossier vulkansdk/macOS/lib et répétez l'opération pour libvulkan.1.dylib et libvulkan.1.x.xx .dylib (où les x correspondent à la version du SDK que vous avez téléchargé).

Maintenant que vous avez ajouté ces bibliothèques, remplissez le champ Destination avec « Frameworks » de l’onglet Copy Files, supprimez le sous-chemin et décochez « Copy only when installing ». Cliquez sur le « + » et ajoutez-y les trois frameworks.

Votre configuration Xcode devrait ressembler à cela :

Il ne reste plus qu'à définir quelques variables d'environnement. Sur la barre d'outils de Xcode allez à Product → Scheme → Edit Scheme..., et dans l’onglet Arguments ajoutez les deux variables suivantes :

• VK_ICD_FILENAMES = vulkansdk/macOS/etc/vulkan/icd.d/MoltenVK_icd.json ;
• VK_LAYER_PATH = vulkansdk/macOS/etc/vulkan/explicit_layer.d.

Vous avez normalement ceci :

Vous êtes maintenant prêt ! Si vous lancez le projet (en pensant à bien choisir Debug ou Release) vous devrez avoir ceci :

Le nombre d’extensions doit être non nul. Les autres données proviennent de librairies et dépendent de votre configuration.

Vous êtes maintenant prêt à vous lancer avec VulkanDessiner un triangle!