Université Paris 8 - Vincennes à Saint-Denis

Informatique

Synthèse d’Images et OpenGL avecGL4Dummies

Document en cours de rédaction

Farès Belhadj

Date de MAJ : 11 février 2018

email : mailto:amsi@ai.univ-paris8.frgithub : https://github.com/noalien/GL4Dummiesweb : http://api8.fr/GL4D/

Table des matières

1 Introduction 31.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Objectifs du présent ouvrage . . . . . . . . . . . . . . . . . . . 61.3 Conventions de nommage . . . . . . . . . . . . . . . . . . . . . 61.4 Plan de lecture du document . . . . . . . . . . . . . . . . . . . 7

2 Installer GL4Dummies 82.1 À partir du code source . . . . . . . . . . . . . . . . . . . . . 8

2.1.1 Prérequis : la bibliothèque SDL2 . . . . . . . . . . . . 82.1.2 Compilation et installation de GL4Dummies . . . . . . 92.1.3 Paramétrage de vos futurs projets . . . . . . . . . . . . 11

2.2 À partir des binaires . . . . . . . . . . . . . . . . . . . . . . . 11

3 Hello World 123.1 Mon HelloWorld GL4Dummies . . . . . . . . . . . . . . . . . 12

3.1.1 Le Makefile de sample2d_00-1.0 . . . . . . . . . . . . 133.1.2 Le source window.c de sample2d_00-1.0 . . . . . . . . 15

3.2 Principe de fonctionnement d’une application graphique . . . . 183.3 Le HelloWorld multi-coloré . . . . . . . . . . . . . . . . . . . 183.4 Le HelloPixels avec GL4Dummies . . . . . . . . . . . . . . . 20

4 Bases de l’architecture d’un programme OpenGL® 214.1 Environnement de représentation des données . . . . . . . . . 224.2 Les primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.3 Les transformations standards . . . . . . . . . . . . . . . . . . 25

4.3.1 Projection perspective . . . . . . . . . . . . . . . . . . 254.4 Projection orthogonale . . . . . . . . . . . . . . . . . . . . . . 25

1

Liste des codes source

Prototype de Makefile de projet GL4Dummies . . . . . . . . . . . 15Code source du projet sample2d_00-1.0 : écran noir . . . . . . . . . 16Code source du projet sample2d_00-1.1 : écran coloré changeant à

chaque Frame . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Code source du projet sample2d_00-1.2 : dégradé de niveaux de

gris sur un screen de résolution inférieure à celle de la fenêtre . 20

2

Chapitre 1

Introduction

1.1 PrésentationCe document présente des éléments d’introduction à l’apprentissage de la

synthèse d’images (ou les modèles et techniques pour la création d’images nu-mériques et d’animations) à l’aide d’OpenGL®3.3 et plus et de GL4Dummies,une bibliothèque de développement (langage C) rendant plus accessible cetapprentissage aux débutants.

OpenGL® est une Application Programming Interface (API ) ou biblio-thèque de développement standardisée permettant de développer des appli-cations graphiques portables. Initiée par Silicon Graphics en 1992, elle appor-tait un ensemble de fonctionnalités permettant la création, la manipulationet le rendu d’objets géométriques et d’images dans l’espace 2D ou 3D. Sondéveloppement, au travers de spécifications validées par un consortium d’in-dustriels – the OpenGL® Architecture Review Board (ARB) – en a fait unstandard supporté par une majorité de systèmes : systèmes d’exploitation etarchitectures matérielles (constructeurs de cartes graphiques, de dispositifsnomades ou de plateformes embarquées – voir OpenGL®ES pour EmbeddedSystems).

Avant sa version 3.3 et la dépréciation d’un certain nombre de fonction-nalités pratiques, OpenGL®, qui est une API en langage C, permettait, entoute relativité, de facilement créer dans l’espace des modèles géométriquesbasés maillage (les objets sont composés de facettes polygonales), de leurappliquer une ou plusieurs textures, de proposer des propriétés de matière(interaction lumière-matière), de placer une ou plusieurs lumières (différentsmodèles et paramétrages étaient disponibles) et de manipuler l’ensemble desentités virtuelles par le biais de transformations spaciales afin de les mettreen scène et de les rendre à l’écran. Hormis le rendu plat, permettant de cal-

3

culer l’ombrage (ou shading) d’une facette en fonction de son orientation à(aux) la lumière(s), l’autre rendu proposé à l’époque était basé sur l’ombrageGouraud – ou Gouraud shading [Gou71a, Gou71b] – il permet de lisser l’om-brage par interpolation du calcul du niveau d’intensité lumineuse en chaquesommet de la géométrie. Ainsi, sous sa forme initiale, OpenGL® était une bi-bliothèque offrant l’accès à un processus de traitement structuré et figé qui àpartir de données vectorielles et pixelaires permettait d’obtenir certains typesde rendus. Par ailleurs, de nombreuses composantes de ce processus étaientgérées par les pilotes des cartes graphiques permettant un considérable gainde performances. Ainsi, il était difficile, voire impossible, de proposer et d’im-plémenter d’autres types de traitements ou obtenir d’autres types de rendusà moins d’abandonner 1 l’usage de l’accélération matérielle. C’est donc en2003, et sa version 1.5, que la spécification OpenGL® donne la possibilité dereprogrammer, directement dans le GPU (Graphics Processing Unit), cer-taines parties du processus de traitement, au début en assembleur, puis enGLSL (OpenGL® Shading Language, langage de programmation proche dulangage C et permettant la surcharge de fonctions et la gestion d’opérationssur vecteurs et matrices).

Ainsi, depuis la version 3.3 d’OpenGL®, d’anciennes fonctionnalités dé-préciées depuis la version 2.0 ont été officiellement supprimées 2 ; citons-enquelques unes :

Fonctions de description de géométrie : ensemble de fonctions per-mettant de créer/initier/clôturer/utiliser une géométrie (glNewList,glEndList, glBegin, glEnd, ...), d’injecter des sommets (glVertex),leur couleur (glColor), leur vecteur normal (glNormal) et leurs coor-données de textures (glTexCoord), ...

Transformations spaciales : deux types de matrices, la première per-mettant de stocker les opérations liées à la modélisation des objets

1. En 2001, notre première tentative de proposition d’un rendu alternatif de scènes3D – rendu par mosaïques exploitant les diagrammes de VoronoÏ – nous contraignait àreprendre la bibliothèque MesaGL afin d’en réécrire la partie gérant le calcul des valeursdes pixels au niveau du Frame-Buffer. MesaGL, ou Mesa 3D Graphics Library (https://www.mesa3d.org), est une bibliothèque open source représentant une implémentationsemi-matérielle ou logicielle d’OpenGL®.

2. Il existe néanmoins une possibilité de réactiver ces fonctionnalités par le biais d’unprofil compatibility. Par contre, cette possibilité n’est pas présente sur tous les systèmesd’exploitation ; par exemple, sous OSX, le driver OpenGL® ne peut fonctionner que surun mode “ancien OpenGL®” (versions antérieures à 3) ou “OpenGL® actuel” et il n’estpas possible d’exploiter les anciennes fonctionnalités sur une version 3 et plus. Enfin, ilfaut comprendre que ce mode compatibility existe afin de permettre à d’anciennes grossesapplications de l’industrie de la CAO de continuer à être maintenues et fonctionner maisqu’il est un frein au développement de l’API .

4

(placement des objets dans la scène) et à la vue (emplacement virtuelde l’utilisateur observant la scène), la seconde permet de paramétrerla projection de la scène à l’écran. De plus, des fonctions permettaientde gérer ces matrices sous la forme de piles de données donnant lapossibilité de les sauvegarder et les restaurer ; d’autres permettaientd’y insérer des transformations telles que la rotation (glRotate), latranslation (glTranslate) ou la mise à l’échelle (glScale), ...

Lumières : ensemble de fonctions d’activation, paramétrage et gestiondes lumières de la scène ;

Rendus : le rendu coloré, le rendu ombrage-plat et l’ombrage Gourauddisparraissent et plus aucun rendu “par défaut” n’est proposé ; la spé-cification du flux de données étant entièrement décidée par l’utilisa-teur, l’idée d’un rendu par défaut devient caduque ;

...Enfin, nous complétons la liste des fonctionnalités supprimées en citant

deux API très utiles et devenues quasiment obsolètes depuis la version 3.3d’OpenGL® : GLU (OpenGL® Utility Library) et GLUT (OpenGL® UtilityToolkit). La première permettait par exemple de créer et paramétrer desobjets géométriques complexes tels que les courbes ou les surfaces paramé-triques. La seconde gérait le fenêtrage, les interaction, les menus et permet-tait simplement de créer des objets géométriques basiques tels que le cube,la sphère ou la TeaPot (voir GLUT teapot dans votre moteur de recherchefavori).

C’est dans ce contexte et afin de faciliter l’initiation, l’uniformisation del’installation et la gestion des nouvelles possibilités offertes par la nouvelle ar-chitecture OpenGL® qu’a été pensée et initiée la bibliothèque GL4Dummies.GL4Dummies donne accès, dans la nouvelle architecture OpenGL®, à un en-semble de fonctionnalités reprenant dans la mesure du possible le modèlede celles supprimées depuis la version 3.3 ; ses fonctionnalités s’insèrent na-turellement dans le modèle aujourd’hui programmable et accessible via lelangage GLSL. GL4Dummiesest une API en cours de développement, ellesert de support de développement pour l’ensemble des cours liés à la syn-thèse d’images et enseignés à l’Université Paris 8 depuis 2014 ; nous incitonsles personnes souhaitant participer à son développement de le faire.

5

1.2 Objectifs du présent ouvrageLe but du présent document est d’exposer les principales fonctionnali-

tés 3 des API OpenGL® et GL4Dummies et de les mettre en œuvre à l’aided’exemples simples. Vous serez alors amener de manière progressive à utiliserces acquis dans le cadre d’un projet personnel plus complexe

Par ailleurs, ce document est en constante évolution, si vous y découvrezdes erreurs ou coquilles, n’hésitez pas à contacter les auteurs. Préférez l’uti-lisation d’un lecteur pdf supportant les liens hypertextes car de nombreuxliens vous conduisent vers des sources de documentation.

Enfin, les exercices sont donnés pour entrainer le lecteur aux différentestechniques exposées.

1.3 Conventions de nommageIci nous décrivons les conventions de nammages adoptées dans les API

OpenGL® et GL4Dummies. Ceci permettra au lecteur d’identifier plus aisé-ment l’origine du type ou de la fonction et dans la mesure du possible sonusage.

L’API OpenGL® adopte une convention de nommage proche de celleutilisée en langage Java (voir Naming conventions dans [jav97]). L’ensembledes éléments provenant de l’API OpenGL® sont préfixés des deux lettres gl.De la même manière, GL4Dummies suivra cette convention de nommage enpréfixant par gl4d. Ces lettres se présentent en minuscule pour les fonctionset en majuscule pour les macros et types de données 4. Ainsi une fonctionOpenGL® peut prendre la forme suivante :

glNomCourt{u}{bsifd}{v}(type1 v1, type2 v2, ...);

où le nom court étant le nom de la fonctionnalité. Il peut être suffixé d’élé-ments informant sur la nature et le type de données d’un sous-ensemble oude l’intégralité des arguments de la fonction :

— La présence de la lettre u indique que le type de données du ou desargument(s) ciblé(s) est non signé. Ce suffixe n’est valable que dansles cas où il serait suivi de b, s ou i ;

3. Si vous souhaitez consulter une référence plus complète, reprenant en détail lesfonctionnalités de l’API , l’ouvrage The OpenGL Programming Guide - The Red book[SWND05] reste incontournable. L’édition liée à la version 1.1 d’OpenGL® est disponiblegratuitement sur http://www.glprogramming.com/red/

et demeure suffisante pour une compréhension des mécanismes liés à la programmationde l’ancienne version de l’API dont les fonctionnalités réintroduites dans GL4Dummies.

4. Au préfixe près, il en est de même pour les API GLU , GLUT ou SDL2 .

6

— La présence d’une des lettres {b, s, i, f, d} indique le type dedonnées du ou des argument(s) ciblé(s). Nous donnons, ci après, letype en fonction de la lettre présentée :b indique un mot (ou byte) qui serait l’équivalent, en langage C, d’un

char. Le type de données OpenGL® correspondant est le GLbyte,l’espace mémoire occupé est de 8 bits ;

s indique un entier court qui serait l’équivalent, en langage C, d’unshort. Le type de données OpenGL® correspondant est le GLshort,l’espace mémoire occupé est de 16 bits ;

i indique un entier qui serait l’équivalent, en langage C, d’un intou d’un long. Le type de données OpenGL® correspondant est leGLint le GLsizei, l’espace mémoire occupé est de 32 bits ;

f indique un nombre à virgule flottante sur 32 bits qui serait l’équi-valent, en langage C, d’un float. Le type de données OpenGL®

correspondant est le GLfloat ou le GLclampf ;d indique un nombre à virgule flottante sur 64 bits qui serait l’équi-

valent, en langage C, d’un double. Le type de données OpenGL®

correspondant est le GLdouble ou le GLclampd.— La présence de la lettre v indique que le ou les arguments ciblés sont

des vecteurs (des tableaux de données).

TODO : ajout d’un descriptif sur le choix des préfixes GL4Dummies permettantde déduire la famille de fonctionnalités ciblées et les fichiers concernés dansla documentation de référence écrites en, et générée par Doxygen.

1.4 Plan de lecture du documentTODO.

Le chapitre 2 donne des indications sur l’installation des outils et des APInécessaires à la réalisation des exemples donnés dans le présent support.

Dans le chapitre 3, nous aborderons sans détour l’écriture d’un codeminimal permetant de fabriquer un programme utilisant GL4Dummies etOpenGL® et introduisant la notion de pixel à l’aide d’une représentationsimple. La notion de boucle d’affichage sera introduite dans ce chapitre.

Une introduction à une architecture simplifiée du pipeline OpenGL® estdonnée dans le chapitre 4 ; nous y aborderons la mise en place, côté CPU , dedonnées vectorielles, le transfert et la description de ces données vers le GPU ,la création d’un programme de rendu les prenant en compte et le rendu àproprement parler.

7

Chapitre 2

Installer GL4Dummies

2.1 À partir du code sourceCette section décrit l’installation de la bibliothèque GL4Dummies à partir

de son code source. Dans chaque sous-partie vous trouverez les indications àsuivre en fonction de votre système d’exploitation : Linux / Unix-like / MacOS X et Windows.

2.1.1 Prérequis : la bibliothèque SDL2SDL2 (http://www.libsdl.org/) est une bibliothèque de développement

multi-plateformes permettant un accès hardware aux ressources graphiquesprésentes sur le système. Elle permet aussi l’accès bas niveau aux ressourcesd’interface (clavier, souris et joystick). Aussi, des extensions de la biblio-thèque donnent un accès simple aux ressources audio, à la gestion des pthread,à l’utilisation de fonts Truetype, à l’ouverture et l’enregistrement de multiplesformats d’images, etc.

GL4Dummies dépend de la bibliothèque SDL2 principalement pour ce quiconcerne la gestion de fenêtres et du contexte OpenGL® (pour faire court :zone de l’écran dans laquelle OpenGL® effectue ses rendus). Il est néces-saire d’avoir la bibliothèque de développement (soit les paquets contenantles headers et les bibliothèques statiques) de SDL2 afin de pouvoir recompi-ler GL4Dummies. Aussi, pour de nombreux exemples proposés dans la suite,il sera nécessaire d’avoir certaines extensions de la bibliothèque, telles que :SDL_images, SDL_mixer et SDL_ttf. Faire attention à récupérer les ver-sions pour SDL2 et non SDL1.2 (l’ancienne version de la bibliothèque nepermet pas de gérer un contexte OpenGL® 3 et plus).

Afin de vérifier que SDL2 est bien installée, et pour faire simple, nouspouvons considérer que la bibliothèque de développement est présente sur le

8

système si la commande sdl2-config est présente et répond en donnant lesbons chemins vers les différents fichiers (voir sdl2-config --help). Sinon,en fonction de l’OS (système d’exploitation) faire :

Pour les utilisateurs Linux, utiliser le gestionnaire de paquets afind’installer la la bibliothèque de développement (lib dev) de SDL2 .Par exemple un utilisateur Ubuntu fera :sudo apt-get install libsdl2-dev

Pour les utilisateurs Mac OS X, commencer par installer les Mac-Ports (http://www.macports.org). Une fois les MacPorts pleinementfonctionnels, installer SDL2 en tapant (dans un terminal) :sudo port install libsdl2

Pour les utilisateurs Windows, pas besoin d’installer SDL2 tout estdans l’archive GL4Dummies sauf si vous souhaitez utiliser une versionplus récente de SDL2 .

Enfin, il est aussi possible d’installer SDL2 à partir de son source, néanmoins,cette procédure n’est pas recommandée car certaines dépendances liées auxexemples ne seront pas automatiquement incluses dans la bibliothèque ; parexemple : le support de différents formats d’images ou de fichiers audio.

2.1.2 Compilation et installation de GL4DummiesDans un premier temps, il s’agit de récupérer le code source de la biblio-

thèque :— Soit en récupérant une release GL4Dummies et en la décompressant

(par exemple : tar zxvf gl4dummies-X.Y.Z.tar.gz où X.Y.Z est la ver-sion de la release) afin d’obtenir le dossier souces de GL4Dummies ;

— Soit en récupérant directement le GIT (installer git et les outils au-totools automake, autoconf et libtool) :

git clone https://github.com/noalien/GL4Dummies.git GL4Dummiescd GL4Dummiesmake -f Makefile.autotools

Ensuite, aller dans le dossier contenant le code source de GL4Dummies :Sous Posix (Linux, OSX, ...) avec droits administrateur, faire :

./configuremakesudo make install

9

Puis, sur certains Linux, il est nécessaire de spécifier que la variabled’environnement $LD_LIBRARY_PATH pointe sur /usr/local/lib. Ainsi,selon votre OS, à la racine de votre compte, vous devriez avoir (parordre de préférence) un ou plusieurs des fichiers suivants : .bashrc,.bash_profile, ou .profile. Editez l’un d’eux en ajoutant la lignesuivante à la fin du fichier :export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib

Ces fichiers permettent de paramétrer votre environnement utilisateurau moment du login (.bash_profile ou .profile) ou lors de l’ouver-ture d’un nouveau bash (.bashrc). Pour forcer la relecture d’un de cesfichiers de paramétrage, utilisez la commande source. Par exemple, sivous aviez ajouté les deux lignes au .bashrc, faire :source ~/.bashrc

Sous Posix (Linux, OSX, ...) sans droits administrateur, il peutêtre nécessaire de créer un dossier local à la racine de votre compte et yinstaller la bibliothèque (bibliothèque statique et dynamique, headerset autres fichiers nécessaires). En premier lieu, vérifiez que votre va-riable d’environnement $HOME pointe bien à la racine de votre compte(echo $HOME) et tapez :[ -d $HOME/local ] || mkdir $HOME/local./configure --prefix=$HOME/localmakemake install

et là il vous reste à paramétrer vos chemins en fonction de $HOME/localoù l’installation a été faite.Pour que le système ait connaissance de ce chemin d’installation par-ticulier (les dossiers bin include lib et share ont été ajoués dans$HOME/local) il faut renseigner ses variables d’environnement $PATHet $LD_LIBRARY_PATH. Selon votre OS, à la racine de votre compte,vous devriez avoir (par ordre de préférence) un ou deux des fichierssuivants .bashrc, .bash_profile, ou .profile. Éditez l’un d’eux enajoutant les deux lignes suivantes à la fin du fichier :export PATH=$PATH:$HOME/local/binexport LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/local/lib

Ces fichiers permettent de paramétrer votre environnement utilisateurau moment du login (.bash_profile ou .profile) ou lors de l’ouver-ture d’un nouveau bash (.bashrc). Pour forcer la relecture d’un de ces

10

fichiers de paramétrage, utilisez la commande source. Par exemple, sivous aviez ajouté les deux lignes au .bashrc, faire :source ~/.bashrc

Sous Windows, ouvrir le répertoire Windows à l’emplacement conte-nant le code source deGL4Dummies, et, selon votre IDE : Code::blocks,Dev C++ ou Visual Studio Express, vous trouverez respectivement unprojet GL4Dummies.cbp, GL4Dummies.dev ou GL4Dummies.sln. Ouvrezcelui qui correspond à votre IDE et compiler le projet. Dans le casde Visual Studio, il compilera la bibliothèque puis les exemples uti-lisant la bibliothèque, il ne reste plus qu’à exécuter. Dans le cas deCode::blocks et Dev C++, la bibliothèque est compilée et les binairescréés dans le dossier bin/Win32 à partir de la racine du dossier conte-nant les sources. Les projets exemples (.cbp ou .dev) se trouvant dansWindows peuvent maintenant être compilés et exécutés.

2.1.3 Paramétrage de vos futurs projetsEn fonction de l’emplacement où est installée la GL4Dummies, il faudra

paramétrer vos futurs projets (par exemple paramétrer le Makefile) pourqu’ils puissent compiler et linker avec GL4Dummies. Vous devez ainsi véri-fier que la ligne de compilation contient bien le chemin vers le dossier includede GL4Dummies et que la ligne de link (ld) contient le chemin vers le dossierlib et demande à utiliser glAd (par exemple -lGL4Dummies).

Par exemple, quand la bibliothèque est installée dans un $HOME/local,en utilisant un Makefile, vérifier dans ce dernier que les variables CPPFLAGSet LDFLAGS contiennent au minimum :

CPPFLAGS = -I. -I$(HOME)/local/include $(shell sdl2-config --cflags)LDFLAGS = -lm -L$(HOME)/local/lib -lGL4Dummies $(shell sdl2-config --libs)

2.2 À partir des binairesActuellement aucune version binaire n’est officiellement distribuée.

11

Chapitre 3

Démarrage rapide

Ce chapitre traite de la mise en place d’un premier projet utilisant l’APIGL4Dummies et par conséquent OpenGL®. Nous ferons évoluer ce projetafin d’y introduire la notion du pixel et de sa représentation sans pour au-tant aborder le côté OpenGL® qui est bien présent mais reste caché pardes notions haut-niveau apportées par GL4Dummies. Nous terminons parune introduction à la boucle d’affichage et l’ajout d’interactions simples avecl’utilisateur.

Des exercices sont proposés en fin de chapitre.

3.1 Mon HelloWorld GL4DummiesCommençons par le premier Sample Project (projet échantillon) pré-

sent dans les sources de la bibliothèque GL4Dummies. Il s’agit du projetsamples/sample2d_00-1.0 que l’utilisateur peut compiler (sous un systèmePosix 1) en se rendant dans le dossier et en saisissant la commande make ←↩

puis, si tout se déroule correctement (pour cela, il est nécessaire de réussir àinstaller GL4Dummies tel que décrit dans le chapitre 2) lancer l’exécutableproduit en saisissant ./sample2d_00 ←↩ . Ce qui donne :MacBook -Pro -de-Fares:GL4Dummies amsi$ cd samples/sample2d_00 -1.0/MacBook -Pro -de-Fares:sample2d_00 -1.0 amsi$ lsCOPYING Makefile documentation window.cMacBook -Pro -de-Fares:sample2d_00 -1.0 amsi$ makegcc -I. -I/usr/local/include -I/opt/local/include/SDL2 -D_THREAD_SAFE -Wall -O3 -mmacosx -version -min =10.8

-c window.c -o window.ogcc window.o -lm -L/usr/local/lib -framework OpenGL -mmacosx -version -min =10.8 -lGL4Dummies -L/opt/local/lib

-lSDL2 -o sample2d_00MacBook -Pro -de-Fares:sample2d_00 -1.0 amsi$ ./ sample2d_00OpenGL version: 4.1 NVIDIA -10.17.5 355.10.05.45 f01

1. Posix concerne tous les systèmes Unix-Like comprenant Linux, FreeBSD, Mac OS Xet même l’utilisation de cygwin ou mingw32 sous Windows. Par contre, si vous utilisezdes IDE tels que Code::blocks ou Visual Studio voir les solutions présentes dans le dossierWindows.

12

Supported shaders version: 4.10GL4D/gl4du.c (344): Creation du programme 1 a l’aide des Shaders :gl4dp_basic_with_transforms.vs : vertex shadergl4dp_basic.fs : fragment shader

Ainsi, une exécution réussie du Sample Project sample2d_00-1.0 ouvre unefenêtre de 320× 240 pixels, portant le titre “GL4Dummies’ Hello World” etaffichant un fond noir telle qu’illustrée par la figure 3.1. Il est à noter quecette fenêtre possède un bouton permettant sa fermeture, un autre pour laréduire et que le bouton permettant le redimensionnement (s’il est présent)n’est pas actif. L’application quitte (donc la fenêtre se ferme) si l’utilisa-teur clique sur le bouton fermer. Ses comportements sont programmés etle lecteur les découvrira au fur et à mesure. Enfin, notons que si l’appli-cation est lancée depuis un terminal des nombres apparaissent toutes les 5secondes. Ces nombres correspondent au Framerate de l’application ; soit lenombre d’images par seconde qu’elle produit. Il est fréquent que ce nombrecorresponde à 60 car classiquement les drivers (pilotes) de cartes graphiquesbloquent la fréquence de rafraîchissement afin de la synchroniser avec cellede l’écran (télévision ou vidéo-projecteur) qui est souvent à 60Hz. Enfin, enfonction du système et des pilotes fournis, il existe des outils permettant dedésactiver cette synchronisation verticale.

Figure 3.1 – Résultat du Sample Project sample2d_00-1.0

3.1.1 Le Makefile de sample2d_00-1.0

Le fichier Makefile de ce projet donné par le Code source 3.1 est lefichier indiquant comment “fabriquer” des choses dans le projet. Ici, sans

13

entrer dans le détail d’écriture d’un Makefile, nous nous intéressons à deuxaspects : les actions possibles ; le paramétrage pour les futurs projet du lec-teur.

1. La cible principale est make ou make all ; et elle a pour objectif defabriquer ou de mettre à jour le programme dont le nom est stockédans la variable $(PROGNAME). De manière classique le make clean sup-prime l’ensemble des fichiers générés (ou générables) pour ne garderque le strict minimum de sources nécessaires au projet. En présencede l’outil doxygen 2, la commade make doc utilise le fichier de confi-guration Doxyfile présent dans le sous-dossier documentation pourgénérer la documentation dans le dossier documentation/html/. En-fin, make dist fabrique automatiquement une archive .tgz contenantl’ensemble des fichiers sources réunis dans la variable $(DISTFILES) ;le nom de cette archive dépend du nom du programme et de sa version.

2. Sans être expert d’écriture de Makefile, il est possible de modulercelui fourni ici afin de le faire correspondre à un autre projet. Ci-aprèsune liste de variables pouvant être modifiées sans trop de risques :CFLAGS contient les option de compilation pour gcc, remplacer par

exemple le -O3 par un -g pour activer la génération de symbolespour faciliter le débogage avec gdb (ne pas omettre de faire unmake clean avant de recompiler) ;

CPPFLAGS afin d’ajouter des chemin vers d’autres répertoires conte-nant des fichiers à inclure (#include <...>) ;

LDFLAGS afin d’ajouter des chemin vers d’autres répertoires conte-nant des bibliothèques (static or dynamic libs) à utiliser ansi queles options de lien (link) ;

PROGNAME permet de changer le nom du programme et du projet ;VERSION permet de changer la version du projet ;HEADERS liste de noms de fichiers en-tête (headers ou .h) faisant par-

tie des fichiers sources du projet. Ces noms doivent être séparéspar des espaces ;

SOURCES liste de noms de fichiers sources-compilables (.c) faisantpartie du projet. Ces noms doivent être séparés par des espaces ;

EXTRAFILES si nécessaire, d’autres fichiers à inclure dans l’archive duprojet.

2. Doxygen est un outil libre permettant de produire une documentation de référence àpartir de commentaires de codes sources formatés spécifiquement ; Doxygen s’inspire de Ja-vadoc en l’élargissant à de nombreux langages de programmation. Cet outil est disponiblepour de nombreuses plateformes sous la forme de package.

14

# Makefile# Auteur : Farès BELHADJ# Email : amsi@ai.univ -paris8.fr# Date : 04/02/2018# définition des commandes utiliséesCC = gccECHO = echoRM = rm -fTAR = tarMKDIR = mkdirCHMOD = chmodCP = rsync -R# déclaration des options du compilateurCFLAGS = -Wall -O3CPPFLAGS = -I.LDFLAGS = -lm# définition des fichiers et dossiersPROGNAME = sample2d_00VERSION = 1.0distdir = $(PROGNAME)-$(VERSION)HEADERS =SOURCES = window.cOBJ = $(SOURCES :.c=.o)DOXYFILE = documentation/DoxyfileEXTRAFILES = COPYING $(wildcard shaders /*.?s images /*.png)DISTFILES = $(SOURCES) Makefile $(HEADERS) $(DOXYFILE) $(EXTRAFILES)# Traitements automatiques pour ajout de chemins et options (ne pas modifier)ifneq (,$(shell ls -d /usr/local/include 2>/dev/null | tail -n 1))

CPPFLAGS += -I/usr/local/includeendififneq (,$(shell ls -d $(HOME)/local/include 2>/dev/null | tail -n 1))

CPPFLAGS += -I$(HOME)/local/includeendififneq (,$(shell ls -d /usr/local/lib 2>/dev/null | tail -n 1))

LDFLAGS += -L/usr/local/libendififneq (,$(shell ls -d $(HOME)/local/lib 2>/dev/null | tail -n 1))

LDFLAGS += -L$(HOME)/local/libendififeq ($(shell uname),Darwin)

MACOSX_DEPLOYMENT_TARGET = 10.8CFLAGS += -mmacosx -version -min=$(MACOSX_DEPLOYMENT_TARGET)LDFLAGS += -framework OpenGL -mmacosx -version -min=$(MACOSX_DEPLOYMENT_TARGET)

elseLDFLAGS += -lGL

endifCPPFLAGS += $(shell sdl2 -config --cflags)LDFLAGS += -lGL4Dummies $(shell sdl2 -config --libs)all: $(PROGNAME)$(PROGNAME): $(OBJ)

$(CC) $(OBJ) $(LDFLAGS) -o $(PROGNAME)%.o: %.c

$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@dist: distdir

$(CHMOD) -R a+r $(distdir)$(TAR) zcvf $(distdir).tgz $(distdir)$(RM) -r $(distdir)

distdir: $(DISTFILES)$(RM) -r $(distdir)$(MKDIR) $(distdir)$(CHMOD) 777 $(distdir)$(CP) $(DISTFILES) $(distdir)

doc: $(DOXYFILE)cat $< | sed -e "s/PROJECT_NAME␣*=.*/ PROJECT_NAME␣=␣$(PROGNAME)/" |\

sed -e "s/PROJECT_NUMBER␣*=.*/ PROJECT_NUMBER␣=␣$(VERSION)/" >> $<.newmv -f $<.new $<cd documentation && doxygen && cd ..

clean:@$(RM) -r $(PROGNAME) $(OBJ) *~ $(distdir).tgz gmon.out core .*\

documentation /*~ shaders /*~ documentation/html

Code source 3.1 – Prototype de Makefile de projet GL4Dummies

3.1.2 Le source window.c de sample2d_00-1.0

Dans ce Sample Project le seul fichier strictement nécessaire à la fabri-cation du programme est window.c, il est listé dans le Code source 3.1.

15

Pour des raisons de lisibilité, nous avons supprimé les commentaires contenusdans le code téléchargeable et commenterons les principaux éléments de ceprogramme.

#include <GL4D/gl4dp.h>#include <GL4D/gl4duw_SDL2.h>int main(int argc , char ** argv) {

if(! gl4duwCreateWindow( argc , argv , "GL4Dummies ’␣Hello␣World",10, 10, 320, 240, GL4DW_SHOWN) ) {

return 1;}gl4dpInitScreen ();gl4dpClearScreen ();gl4dpUpdateScreen(NULL);gl4duwMainLoop ();return 0;

}

Code source 3.1 – Code source du projet sample2d_00-1.0 : écran noir

Dans les grandes lignes, ce programme créé une fenêtre à l’aide de lafonction gl4duwCreateWindow ; créé, efface en noir puis met à jour un screenrespectivement avec les fonctions gl4dpInitScreen, gl4dpClearScreen etgl4dpUpdateScreen ; et enfin se lance dans une boucle d’affichage infinie.

Le fichier header gl4dp.h contient les macros, structures et prototypesde fonctions liées aux primitives de dessin 2D ; la lettre p de gl4dp.h corres-pondant à primitives mais aussi à pédagogique car cette partie de la biblio-thèque n’a pas pour vocation de proposer des outils de primitives optimisésmais possède une priorité pédagogique.

Le fichier header gl4duw_SDL2.h contient pour sa part les macros, struc-tures et prototypes de fonctions liées à la gestion des fenêtres et à la gestiondes fonctionnalités qui y sont liées.

La fonction gl4duwCreateWindow :

Cette fonction permet de créer une fenêtre pour GL4Dummies et initialisela bibliothèque. Sont prototype est le suivant :GLboolean gl4duwCreateWindow(int argc , char ** argv ,

const char * title , int x, int y,int width , int height , Uint32 wflags);

les deux premiers arguments proviennent des arguments du main et per-mettent à la bibliothèque d’initialiser son contexte (principalement utile pourconnaître les chemin vers le binaire et pouvoir trouver les dépendances –comme les fichiers shaders – de manière relative). Le troisième argument estle titre de la fenêtre, il peut aussi servir à retrouver la fenêtre parmi plusieursautres afin de lui affecter le statut “courante”. x, y, width et height donnentposition et dimensions de la fenêtre lors de la création. wflags est un entiernon signé permettant de stocker des options relatives à la fenêtre commepar exemple : est-elle redimensionnable, visible, ... Nous laisserons le lecteurdécouvrir plus de détails en le renvoyant sur la documentation de référence.

16

Enfin, cette fonction revoie un booléen afin d’indiquer si la création de lafenêtre a réussi ou échoué. L’échec peut être causé par l’absence de contextegraphique ou l’impossibilité d’ouvrir un contexte OpenGL® 3.2 (valeur pardéfaut dans GL4Dummies, voir la fonction gl4duwSetGLAttributes).

Le screen et la fonction gl4dpInitScreen :

Le screen est un écran virtuel géré par GL4Dummies et représentantun tableau de données proportionnel aux dimensions de la fenêtre quand lescreen est créé à l’aide de la fonction gl4dpInitScreen (voir aussi la fonc-tion gl4dpInitScreenWithDimensions pour des screens aux dimensions dif-férentes de la fenêtre). Ci-après le prototype des fonctions InitScreen :GLuint gl4dpInitScreen(void);GLuint gl4dpInitScreenWithDimensions(GLuint w, GLuint h);

Ces fonctions renvoient donc un identifiant de screen permettant, en casde multiples screens, de passer de l’un à l’autre, afin d’effacer, dessiner, sup-primer, ... Par ailleurs, la structure intrinsèque à un screen est simple, ellecontient autant d’entiers non signés que de pixels. Pour faire simple, soit pourun screen de dimensions w× h la partie données du screen est comparable àun :unsigned int data[w * h];

Nous inviton le lecteur à se rendre à la section 3.4 pour en savoir un peuplus sur ce qu’est un pixel, une de ses représentations simples adoptées dansla partie “pédagogique” (gl4dp.h) de GL4Dummies, et comment faire sonpremier programme créant un dégradé de pixels.

La fonction gl4dpClearScreen :

Cette fonction efface le screen en cours en y mettant des zéros (0). Enpratique, cette fonction utilise un memset avec comme second argument 0 afinde remplir tous les octets de zéros ce qui produit un écran noir (les pixelscontenant l’intensité de chaque couleur, l’omni-présence de zéros produit uneimage à intensité nulle donc noire). Pour un effacement avec une autre couleurvoir la fonction gl4dpClearScreenWith(Uint32 color).

La fonction gl4dpUpdateScreen :

Sans rentrer dans les détails, cette fonction permet de communiquer entrela mémoire centrale, la RAM-CPU, et la mémoire graphique, la RAM-GPU.La données est partiellement ou dans sa globalité transférée vers OpenGL®

17

pour que son état actuel en RAM-CPU soit reproduit à l’écran. Ci-après leprototype de la fonction :void gl4dpUpdateScreen(GLint * rect);

où rect représente le rectangle, sous partie du screen, à mettre à jourcôté GPU . C’est le pointeur vers les quatre entiers positifs x,y – coin hautgauche du rectangle – et w,h – ses dimensions.

La fonction gl4duwMainLoop :

Enfin, nous revenons vers une fonction liée à la gestion du fenêtrage. Uneapplication fenêtrée est un processus qui demeure alive (en quelques sortes“vivant”) au sein du système tant qu’il ne reçoit pas d’événement ou designal lui indiquant ou le forçant à quitter. Donc, par définition, dans ce typed’applications il est nécessaire de produire une boucle infinie 3 dont le corpsest en attente d’un signal de sortie. Afin de ne pas accaparer les ressourcesdu système cette boucle doit ordonnancer les tâches à faire pour permettre àla fois d’écouter les événements, réagir en fonction et procéder à l’affichage.C’est le rôle de la fonction gl4duwMainLoop dont nous abordons le principegénérale dans la section 3.2 ci-après.

3.2 Principe de fonctionnement d’une appli-cation graphique

3.3 Le HelloWorld multi-coloré#include <GL4D/gl4dp.h>#include <GL4D/gl4duw_SDL2.h>

static void quitte(void) {gl4duClean(GL4DU_ALL);

}

static void dessine(void) {GLubyte r = rand() % 256, g = rand() % 256, b = rand() % 256;gl4dpClearScreenWith(RGB(r, g, b));gl4dpUpdateScreen(NULL);

}

int main(int argc , char ** argv) {if(! gl4duwCreateWindow(argc , argv , "GL4Dummies ’␣Hello␣World",

10, 10, 320, 240, GL4DW_SHOWN) ) {return 1;

}gl4dpInitScreen ();atexit(quitte);gl4duwDisplayFunc(dessine);gl4duwMainLoop ();return 0;

}

3. À moins d’utiliser une sorte variable globale servant de test de boucle et passant àfaux par le biais d’un événement extérieur.

18

Figure 3.2 – Principe général du fonctionnement d’une application gra-phique avec la boucle événements–simulation–dessin

19

Code source 3.1 – Code source du projet sample2d_00-1.1 : écran coloré changeantà chaque Frame

3.4 Le HelloPixels avec GL4Dummies#include <GL4D/gl4dp.h>#include <GL4D/gl4duw_SDL2.h>

static void quitte(void) {gl4duClean(GL4DU_ALL);

}

static void dessin(void) {int x, y;Uint32 c;for(y = 0; y < 16; y++)

for(x = 0; x < 16; x++) {c = y * 16 + x;c = c | (c << 8) | (c << 16) | (c << 24);gl4dpSetColor(c);gl4dpPutPixel(x, y);

}gl4dpUpdateScreen(NULL);

}

int main(int argc , char ** argv) {if(! gl4duwCreateWindow(argc , argv , "GL4Dummies ’␣Hello␣Pixels",

10, 10, 320, 320, GL4DW_SHOWN) ) {return 1;

}gl4dpInitScreenWithDimensions (16, 16);atexit(quitte);gl4duwDisplayFunc(dessin);gl4duwMainLoop ();return 0;

}

Code source 3.1 – Code source du projet sample2d_00-1.2 : dégradé de niveaux degris sur un screen de résolution inférieure à celle de la fenêtre

20

Chapitre 4

Bases de l’architecture d’unprogramme OpenGL®

TODO sections 1 à 4 à revoir

Figure 4.1 – Pipeline OpenGL (3.3) simplifié

21

4.1 Environnement de représentation des don-nées

4.2 Les primitivesPour modéliser des objets, l’élément de base utilisé par l’API OpenGL®est

le sommet — Vertex en anglais. Cette approche donne trois possibilités derendu de l’objet à modéliser :

— Le mode point permet de visualiser l’objet modélisé comme un nuagede points ; une largeur est affectée aux points, elle est utilisée au mo-ment de la rasterization pour lui donner une épaisseur lors du rendusur le framebuffer (pour rappel, en géométrie le point n’a pas d’épais-seur) ;

— Le mode fil de fer permet de visualiser l’objet modélisé à l’aide desegments de droites obtenus en reliant les sommets entre-eux. Ici, lechoix de relier deux sommets n’est pas obtenu par calcul (comme unetriangulation), il est spécifié dans le modèle lui-même. Ainsi, en plusdes sommets, il est nécessaire de décrire la façon dont ces sommetssont reliés. Comme pour le mode point, une largeur est affectée auxsegments, elle est utilisée au moment de la rasterization pour leursdonner une épaisseur lors du rendu sur le framebuffer (pour rappel,en géométrie le segment n’a pas d’épaisseur) ;

— Le mode solide ou plein permet de visualiser l’objet modélisé à l’aidede facettes obtenues en reliant les sommets entre-eux. Afin de dé-crire ces facettes et pour des raisons d’optimisation de vitesse derendu, OpenGL®utilise uniquement des polygones convexes 1 ; dansOpenGL®, le rendu d’un polygone non convexe n’est absolument pasgaranti et peut varier selon l’implémentation de l’API. Comme pourles segments, la façon dont les sommets sont composés pour obtenirdes polygones n’est pas obtenue par calcul, une fois encore, c’est dansle modèle lui-même que cela doit être spécifié.

Ainsi, en pratique, pour modéliser un objet ou une partie d’objet, l’APIOpenGL®fournie un ensemble de commandes permettant de décrire en détailla composition du modèle. Ces commandes donnent la possibilité d’introduiredes données géométriques dans le Pipeline OpenGL®. Pour cela, ces données

1. La restriction de l’API à la seule utilisation de polygones convexes permet de simpli-fier les calculs nécessaires au remplissage des faces et optimiser la vitesse d’exécution durendu. Par ailleurs, cette restriction n’interdit pas la représentation des autres classes depolygones (concaves, croisés ou étoilés) car ces derniers pourront toujours être représentéspar une union de polygones convexes.

22

doivent 2 être déclarée entre la paire de commandes glBegin et glEnd dontvoici les prototypes :

void glBegin(GLenum mode);void glEnd(void);

Chaque sommet est alors déclaré à l’aide des commandes glVertex* et lemodèle est construit en fonction du mode (argument de glBegin) choisi.Nous donnons, ci-après, les valeurs possibles pour le paramètre mode ansique les l’interprétation qui en découle. La figure 4.2 donne un aperçu desrésultats pouvant être obtenus dans chaque situation.Ainsi pour un ensemble de n sommets {V0, V1, ..., Vn−1} déclarés (à l’aide deglVertex*) entre la paire glBegin et glEnd, nous obtenons, quand le modechoisi est :

— GL_POINTS : Tous les sommets sont rendus sous la forme de points ;— GL_LINES : Des segments reliant chaque paire de sommets sont dessi-

nés. Si le nombre de sommets déclarés entre les commandes glBeginet glEnd est impair alors le dernier sommet sera omis ;

— GL_LINE_STRIP : La suite comprenant au minimum deux sommets estreliée par des segments et sans aucune contrainte. Ainsi, pour n ≥ 2,les segments [V0, V1], [V1, V2], ..., [Vn−2, Vn−1] sont dessinés ;

— GL_LINE_LOOP : Identique à GL_LINE_STRIP à l’exception de l’ajoutd’un segment entre les sommets Vn−1 et V0 pour compléter la boucle ;

— GL_TRIANGLES : Dessine pour chaque triplet de sommets un triangle ;les sommets sont pris dans l’ordre et ne sont utilisés qu’une seule fois.Si le nombre de sommets déclarés entre les commandes glBegin etglEnd n’est pas un multiple de trois, le ou les deux sommets restantssont ignorés ;

— GL_TRIANGLE_STRIP : Dessine une bande (le mot stip signifie bande) àl’aide d’un série de triangles. Nous prenons, pour chaque triangle pairde la série les trois premiers sommets dans l’ordre un, deux, trois etpour chaque triangle impair de la série les trois premiers sommets dansl’ordre deux, un, trois, à chaque fois, nous décalons d’une position lepoint de départ de la série avant de continuer sur le reste. Ainsi, pourles six sommets {V0, V1, V2, V3, V4, V5} nous obtenons quatre triangles{V0, V1, V2}, {V2, V1, V3}, {V2, V3, V4} et {V4, V3, V5}, en général, pour nsommets nous obtenons n−2 triangles. Les sommets sont omis si leurnombre est inférieur à trois ;

2. Il existe des alternative à cette méthode de déclaration, nous les aborderons plustard.

23

— GL_TRIANGLE_FAN : Dessine un éventail (le mot fan signifie éventail)à l’aide d’une série de triangles ayant tous pour premier sommet lepremier sommet de toute la série, soit V0. Pour les deux autres som-mets, nous prenons respectivement le deuxième et le troisième sommetdu reste de la série (tous les sommets sauf V0) en décalant cette sé-rie d’une position à chaque nouveau triangle à créer. Ainsi, pour lessept sommets {V0, V1, V2, V3, V4, V5, V6} nous obtenons cinq triangles{V0, V1, V2}, {V0, V2, V3}, {V0, V3, V4}, {V0, V4, V5} et {V0, V5, V6} (dansl’exemple donné en figure 4.2, le sommet V6 est confondu avec le som-met V1 afin d’obtenir un disque), en général, pour n sommets nousobtenons n − 2 triangles. Les sommets sont omis si leur nombre estinférieur à trois.

Figure 4.2 – (Seules) Primitives gérées par OpenGL 3.1 et plus

24

4.3 Les transformations standards4.3.1 Projection perspective

GL4Dummiesoffre la possibilité de calculer une projection dont le point deperspective est l’œil de l’observateur (ou l’objectif de la caméra). Pour cela,il est nécessaire de décrire le plan virtuel (correspondant en définitif à l’écrande l’utilisateur) sur lequel le volume sera projeté ainsi que la profondeur duvolume à projeter. C’est la fonction gl4duFrustum{f|d} qui permet de cal-culer les coefficients de la matrice de projection 3 en fonction des paramètresqui lui sont passés :

void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom,GLfloat top, GLfloat near, GLfloat far);

void glFrustumd(GLdouble left, GLdouble right, GLdouble bottom,GLdouble top, GLdouble near, GLdouble far);

La figure 4.3 illustre le résultat attendu lors de l’utilisation du gl4duFrustum{f|d}.Comme nous pouvons le voir sur ce schéma, le volume projeté s’élargie enfonction de la distance, ainsi, plus nous partons dans les z négatifs plus levolume nous permet d’y placer des objets. D’où, pour des objets de dimen-sions comparables, notons que, une fois projetés, ils parraissent plus petitspour une distance du point de vue qui est plus grande ; le volume subit unecompression plus forte en fonction de la distance, c’est l’effet perspective(pensez à l’image de la route qui fuit vers l’horizon) qui est la conséquencede la transformation du volume projeté initial 4 en un Parallélépipède.

4.4 Projection orthogonaleCe second type de projection, fourni par l’API GL4Dummies, peut être

vu comme un cas particulier de la projection perpective où le point de per-pective fuit à l’infini vers les z positifs. Ici, l’impression d’éloignement liée à

3. En coordonnées homogènes, la projection perspective est donnée par la matrice :

P =

2×nr−l 0 r+l

r−l 00 2×n

t−bt+bt−b 0

0 0 − f+nf−n − 2f×n

f−n

0 0 −1 0

où l, r, b, t, n et f correspondent respectivement aux paramètres left, right, bottom,top, near et far de la fonction gl4duFrustum{f|d} avec r 6= l, t 6= b et f 6= n.

4. Quel est le nom de cet hexahèdre ressemblant à une pyramide dont la cime a ététronquée ?

25

Figure 4.3 – Projection Perspective

26

la distance par rapport au plan de projection (le plan perpendiculaire à l’axedes z et placé en z = Near) n’est plus préservée car tout est projeté orthogo-nalement à ce plan. Ainsi, la fonction gl4duOrtho{f|d} permet de calculerles coefficients de la matrice de projection 5 en fonction des paramètres quilui sont passés :

void glOrthof(GLfloat left, GLfloat right, GLfloat bottom,GLfloat top, GLfloat near, GLfloat far);

void glOrthod(GLdouble left, GLdouble right, GLdouble bottom,GLdouble top, GLdouble near, GLdouble far);

et la figure 4.4 illustre le résultat produit par l’utilisation de cette fonction.

5. En coordonnées homogènes, la projection orthogonale est représentée par la matrice :

P =

2

r−l 0 0 r+lr−l

0 2t−b 0 t+b

t−b

0 0 −2f−n

f+nf−n

0 0 0 1

où l, r, b, t, n et f correspondent respectivement aux paramètres left, right, bottom,top, near et far de la fonction glOrtho avec r 6= l, t 6= b et f 6= n.

27

Figure 4.4 – Projection Orthogonale

28

Bibliographie

[Gou71a] H. Gouraud. Continuous shading of curved surfaces. IEEE Trans.Comput., 20(6) :623–629, June 1971.

[Gou71b] Henri Gouraud. Computer Display of Curved Surfaces. Doctoralthesis, University of Utah, 1971.

[jav97] Java code conventions. from oracle.com, 1997.[SWND05] Dave Shreiner, Mason Woo, Jackie Neider, and Tom Davis.

OpenGL Programming Guide : The Official Guide to LearningOpenGL, Version 2. Addison-Wesley, 2005.

29