Utilisation avancée des processeurs graphiques avec Qt

Utilisation avancée des processeurs graphiques avec Qt par Rémi Achard Guillaume Belz
0.0 - Réorganisation du tutoriel...................................................................................................................................4
1.0 - Introduction..........................................................................................................................................................5
1.0.1 - Contenu du tutoriel et objectifs.................................................................................................................. 5
1.0.2 - Environnement de développement.............................................................................................................5
1.0.3 - Prérequis.....................................................................................................................................................5
1.1 - Architecture des GPU......................................................................................................................................... 6
1.1.1 - Vue générale...............................................................................................................................................6
1.1.2 - Le pipeline graphique................................................................................................................................. 6
1.1.3 - Les mémoires............................................................................................................................................. 7
1.2 - Générer un terrain.............................................................................................................................................. 8
1.2.1 - La classe HeightmapWidget.......................................................................................................................8
1.2.2 - Chargement des données du terrain..........................................................................................................9
1.2.3 - Initialisation de la vue...............................................................................................................................11
1.2.4 - Gestion de la souris et du clavier............................................................................................................ 12
1.2.5 - Mesure des performances........................................................................................................................13
1.2.6 - Gestion des erreurs..................................................................................................................................14
2.0 - Envoyer des données au processeur graphique..............................................................................................15
2.0.1 - Envoi des vertex un par un......................................................................................................................15
2.0.2 - Envoi de tableau de vertices (Vertex Array)............................................................................................ 16
2.0.3 - Utilisation des tableaux d'indices..............................................................................................................17
2.0.4 - Stockage des vertices dans la mémoire du processeur graphique (Vertex Buffer Objects)..................... 18
2.0.5 - Comparaison des performances.............................................................................................................. 20
2.1 - Utilisation du pipeline programmable................................................................................................................22
2.1.1 - La manipulation de shaders avec Qt : QGLShaderProgram et QGLShader............................................23
2.1.2 - Le code source des shaders....................................................................................................................24
2.1.3 - Manipulation des matrices à l'aide de Qt.................................................................................................26
2.1.4 - Passage de paramètres aux shaders...................................................................................................... 27
2.2 - Ajouter des lumières et des textures................................................................................................................30
2.2.1 - Le modèle de Phong................................................................................................................................30
2.2.2 - Chargement de la Normal Map................................................................................................................30
2.2.3 - Afficher les lumières avec les shaders.....................................................................................................31
2.2.4 - Appliquer une texture............................................................................................................................... 33
2.2.5 - Calcul dans le Vertex Shader vs dans le Fragment Shader.................................................................... 35
2.3 - Réaliser un rendu off-screen............................................................................................................................ 38
2.3.1 - Utilisation de QGLPixelBuffer................................................................................................................... 39
2.3.2 - Utilisation de QGLFrameBufferObject...................................................................................................... 41
2.3.3 - Dessiner dans une texture dynamique avec QPainter.............................................................................43
2.4 - Overpainting : dessiner en 2D avec QPainter sur une scène 3D.....................................................................45
2.5 - Gestion des extensions avec QGLContext::getProcAddress()......................................................................... 47
3.0 - Le module Qt3D................................................................................................................................................48
4.0 - Techniques géomtriques................................................................................................................................... 49
4.1 - Lumières et ombres.......................................................................................................................................... 50
4.2 - Rendu................................................................................................................................................................51
4.3 - Images et post-effets........................................................................................................................................ 52
4.4 - Physique............................................................................................................................................................53
4.5 - Ray-tracing et Voxels........................................................................................................................................54
5.0 - Introduction au GPU computing........................................................................................................................55
5.0.1 - Le calcul parallèle.....................................................................................................................................55
5.0.2 - Les API OpenCL...................................................................................................................................... 57
5.0.3 - Installer OpenCL.......................................................................................................................................57
5.0.4 - Installer QtOpenCL................................................................................................................................... 58
5.1 - Le platform layer API........................................................................................................................................59
5.1.1 - Gérer les erreurs...................................................................................................................................... 59
5.1.2 - La plateforme............................................................................................................................................60
5.1.3 - Le device.................................................................................................................................................. 61
5.1.4 - Le contexte............................................................................................................................................... 62
5.1-E - Le programme..........................................................................................................................................62
5.1.6 - Le Command queue.................................................................................................................................63
- 2 -
http://gbelz.developpez.com/remi-achard/gpu-avance-avec-qt/modified/