|
OpenGL (Partie 1) |
|||||||||||||||||||||||||||||||||||||||||||||||
INTRODUCTION
INSTRUCTIONS
VISUALISATION
LES LISTES
LES LUMIÈRES
LES MATÉRIAUX
LES BITMAPS
LE PLACAGE
LES COURBES
LA SÉLECTION
GLSL
|
GL et OpenGL sont des librairies graphiques d'affichage trois dimensions. GL (Iris GL): Librairie graphique standard de Silicon Graphics Inc. (orientée visualisation). Utilisée sur les stations de travail graphiques de SGI (sous système d'exploitation IRIX) ainsi que sur les matériels équivalents d'autres constructeurs (sous licence). OpenGL: Sous-ensemble de GL ne nécessitant pas une licence commerciale SGI Conçu et spécifié à la fin des années 80 - début des années 90 Interface logicielle avec les adaptateurs graphiques 3D Disponible pour un nombre important de plateformes et de langages (initialement C et Fortran) Environ 120 instructions distinctes exécutables au moyen du langage de programmation utilisé Spécification d'objets graphiques et production d’applications graphiques 3D interactives Conçu initialement pour fonctionner en environnement Unix
Standard de la programmation d'applications graphiques en CAO Claire évolution vers l'industrie du jeu (support de techniques de rendu améliorant la qualité des images, exemples: textures évoluées, shaders) Indépendant de la machine hôte Existence des versions successives suivantes (ajout de nouvelles fonctionnalités, compatibilité ascendante?!):
Existence des releases suivantes:
Géré par le consortium OpenGL Khronos (3Dlabs, Apple, ATI, Dell, IBM, Intel, NVidia, Oracle, ..., http://www.opengl.org) Fonctionnalités principales
Exemple
#include <~~~~~~~~.h> Ce programme modélise (dessine) un "carré" blanc au centre d’une "fenêtre" de fond noir. Architecture en pipeline avec des étages successifs réalisant les opérations nécéssaires au processus de visualisation d'une scène (création d'une image) Circulation des données gérées au cours du rendu entre ces étages avec transformations de type au sein des étages:
Fonctionnement en parallèle des étages du pipeline Fonctionnement en mode client-serveur
OpenGL utilise un mode de fonctionnement client-serveur.
Fonctions de base pour l'affichage 3D en OpenGL:
Pas de fonction pour la construction d'une interface utilisateur (fenêtres, souris, clavier, gestionnaire d'événements, ...) Préfixe des fonctions: gl Librairie standard En langage C, déclarations dans le fichier GL/gl.h
Commandes écrites en GL:
Préfixe des fonctions: glu Librairie standard En langage C, déclarations dans le fichier GL/glu.h Bibliothèques associées à OpenGL
Bibliothèque écrite pour rendre simple la programmation de petites applications dans le cadre d'interfaces graphiques interactives simples:
Programmation événementielle Préfixe des fonctions: aux Librairie non standard Librairie non spécifique à un système d'exploitation
Équivalent à Aux du point de vue des fonctionnalités principales et des principes d'utilisation
Interface utilisateur programmable plus élaborée (multifenêtrage, menus popup) Préfixe des fonctions: glut Librairie non standard mais très couramment utilisée quand il s'agit de faire vite et simple sans souci d'intégration poussée avec le système d'exploitation hôte Librairie non spécifique à un système d'exploitation En langage C, déclarations dans le fichier GL/glut.h Fonctionnalités supplémentaires par rapport à Aux:
Syntaxe de la librairie GL (fichier GL/gl.h)
D'une manière générale, emploi des règles syntaxiques du langage C Spécificités supplémentaires:
OpenGL est une machine à états.
-> Des instructions existent pour placer le système dans certains "états" : couleur de tracé, matrice(s) de transformation représentative(s)
du(des) repère(s) courant(s), activation de l'élimination des parties cachées, caractéristiques des lumières, caractéristiques du matériel, caractéristiques
de la texture, ... Chaque fois que le dessin d'un objet est réalisé (sommet, segment de droite, facette), l'ensemble de ces "variables d'états" définit donc la manière avec laquelle l'objet est dessiné. Le dessin d'un objet est définitif. Les modifications ultérieures des variables d'état n'ont aucune influence sur tout ce qui a déjà été dessiné. L'ensemble des variables d'états constitue l'"environnement" OpenGL. Toute variable d'état possède une valeur par défaut affectée à l'amorçage du programme utilisant OpenGL, voire de chaque viewport si plusieurs viewports sont utilisés (plusieurs fenêtres, dessin off-screen). Fonctions de manipulation directe des variables d'état
glEnable(GL_DEPTH_TEST); Active l'affichage avec élimination des parties cachées puis récupère la valeur d'activation de l'affichage avec élimination des parties cachées. Les variables d'état non booléennes sont généralement manipulées au moyen de fonctions dédiées (glMaterial#,glLight#,glNormale#,... , voir plus loin).
L'environnement OpenGL inclut plusieurs tampons mémoire effaçables individuellement ou par lot :
Les valeurs de masque sont composables par "ou" (| en C) pour effectuer plusieurs opérations d'effacement en une seule instruction glClear et rendre possible l'optimisation de ces opérations.
La couleur choisie est active pour tous les objets créés après spécification, jusqu'à nouvelle spécification (sauf si une texture est utilisée). Cette couleur n'est utilisée que si la gestion des lumières et des matériaux est désactivée. En cas d'activation de cette fonctionnalité, ce sont les calculs d'éclairage, compte tenu des lumieres, des matériaux et éventuellement des textures spécifiés, qui permettent le calcul de la couleur des pixels.
Instruction utilisée pour forcer l'exécution entière des commandes GL qui la précèdent dans le flux d'exécution
OpenGL (vidage d'un pipeline d'affichage sur une station graphique, exécution des ordres de tracé sur un réseau, ...). glFinish se met en attente d'une notification d'exécution de la part du dispositif graphique tandis que glFlush n'est pas bloquant.
|
|||||||||||||||||||||||||||||||||||||||||||||||
Généralement, la programmation OpenGL de l'affichage d'une scène correspond à la programmation de l'exécution d'une boucle infinie
d'affichages successifs de cette scène. A chaque affichage la scène doit être entièrement modélisée. L'image est donc entièrement recréée.
L'opération de modélisation d'un objet graphique s'accompagne du dessin dans l'image de cet objet graphique.
while(1) { -> L'élimination des parties cachées n'est pas forcément correctement réalisée car un algorithme du peintre est utilisé pour créer chacune des images. Les objets sont affichés les uns sur les autres dans l'ordre d'exécution du programme et donc l'ordre d'affichage a une influence sur le résultat obtenu. Si l'ordre est bon, l'élimination des parties cachées est réalisée.
-> Utilisation de la fonction glEnable pour
activer l'élimination des parties cachées (généralement par Z-Buffer en
OpenGL) via modification de la variable d'état GL_DEPTH_TEST.
glEnable(GL_DEPTH_TEST);
|
||||||||||||||||||||||||||||||||||||||||||||||||
|
Remarque : OpenGL travaille en coordonnées homogènes.
Par définition, un polygone OpenGL ne se recoupe pas, n'a pas de trou et est de bord convexe.
Cette fonction est utilisée uniquement pour la déclaration de sommets au sein d'une primitive graphique.
Une primitive graphique est constituée d'un ensemble de sommets. Elle est créée par la réalisation des instructions glVertex successives permettant la définition des positions de ses sommets. La primitive est délimitée au début et à la fin par
et
IMPORTANT : A l'exception du cas particulier des bitmaps, la librairie GL ne comporte aucune autre fonction de dessin que celle
permettant de dessiner les 10 primitives existantes. Exemple : Création d'un polygone
glBegin(GL_POLYGON); Outre ses sommets, la définition d'une primitive peut requérir d'autres informations. Celles-ci sont aussi renseignées via des appels à des fonctions particulières réalisés entre glBegin et glEnd.
Parmi ces fonctions, l'une des plus importantes permet la configuration de la valeur de la normale courante (vecteur orthogonal à la surface, utilisé pour les calculs d'éclairage) qui sera attribuée à tout vertex créé :
Exemple
glBegin(GL_POLYGON);
Définit un polygone à trois sommets.
Utilisation fréquente de surfaces polygonales (ensembles de facettes adjacentes) pour modéliser des objets complexes.
#define X .525731112119133606
|
|||||||||||||||||||||||||||||||||||||||||||||||
|