En tout cas, les bases sous Windows !

- Introduction

• C'est quoi OpenGL ?

- Préparer l'environnement de développement pour OpenGL.

• Paramétrer Visual C++
• Paramétrer Dev-C++

- Préparer une fenêtre Windows à recevoir OpenGL.

• Créer une fenêtre
• Récupérer un contexte de périphérique
• Gérer les messages
• Gérer le message WM_ERASEBKGND

- Initialiser et désactiver OpenGL

• Activer OpengGL
  • Definir le format du pixel (PIXELFORMATDESCRIPTOR)
  • Contrôler la valider avec notre carte vidéo et initialisation de celle-ci : ChoosePixelFormat() et SetPixelFormat()
  • Se créer un contexte de rendu : wglCreateContext() sur notre contexte de périphérique
  • Se définir se nouveau contexte comme contexte courant : wglMakeCurrent()
• Désactiver OpenGL
  • Ce qui se traduit par supprimer le contexte de rendu courant: wglMakeCurrent(), wglDeleteContext()
• Fonctions complémentaires
  • Récupérer les contextes de périphérique et de rendu courants : wglGetCurrentDC(), wglGetCurrentContext()

- De la 2D pour étudier les fonctions de bases

• Tout d'abord préparer la surface physique et surface logique qui recevra nos images.
  • Initialiser la couleur de fond (glClearColor())
  • Effacer la surface logique en utilisant la couleur de fond (glClear (GL_COULEUR_BUFFER_BIT))
  • Transférer le rendu final sur la surface physique (glFlush (), glFinish () ou SwapBuffers())
• Dessiner en 2D !
  • Les éléments primitifs
  • Dessiner les éléments primitifs
    • Indiquer le type d'élément primitif par glBegin()
    • Dessiner l'élément primitif via glVertex(), une fonction polyforme...
    • Définir la couleur de l'élément via glColor() (une autre fonction polyforme...) glEnable (GL_COLOR_MATERIAL), glDisable (GL_COLOR_MATERIAL)
      avec une très rapide remarque sur l'existance des fonctions glColorMaterial() et glMaterial().
    • Terminer le dessin du ou des éléments primitifs correspondant par glEnd()
  • Zone de clipping OpenGL dans la zone cliente: le viewport (glViewport())
  • Matrice de projection et matrice de modèle
    • Définition
    • Indiquer la matrice à utiliser (glMatrixMode())
    • Initialiser les matrices avant leur utilisation (glLoadIdentity()) !
  • Dans quel cas utiliser telle ou telle matrice
    • Matrice de modèle
    • Matrice de projection
  • Exemple récapitulatif
  • Tracer des points
    • Modification de la taille (glPointSize())
    • Utilisation de l'anti-aliasing (glIsEnable (GL_POINT_SMOOTH) et glEnable (GL_POINT_SMOOTH))
  • Récupération d'informations sur la gestion du point (glGet).
  • Tracer de lignes
    • Modification de l'épaisseur (glLineWidth())
    • Utilisation de l'anti-aliasing (glIsEnable (GL_LINE_SMOOTH) et glEnable (GL_LINE_SMOOTH))
    • Modification du motif de la ligne (glLineStipple())
    • Mémorisation du motif dans une pile openGL (glPushAttrib() et glPopAttrib())

- De la 2D à la 3D

• La 3ième dimension - les bases
  • La 3ième dimension glVertex(), suite...
  • Le z-buffer:
    • Activer le z-buffer(glEnable (GL_DEPTH_TEST)), le désactiver (glDisable (GL_DEPTH_TEST))
    • Impératif, effacer le z-buffer avant de faire un rendu !( glClear (GL_DEPTH_BUFFER_BIT) )
  • Le culling:
    • Aciver le culling (glEnable (GL_CULL_FACE)), le désactiver (glDisable (GL_CULL_FACE))
    • Et les fonctions associées:glCullFace() et glFrontFace()
• Translations, homothéties et rotations
  • Translations
  • homothéties
  • rotations

- Initialiser ou restaurer une matrice

• Rapide rappel de glLoadIdentity()
• Mémoriser l'état d'une matrice pour restauration ultérieure avec glPushMatrix() et glPopMatrix()
  

- Les display list

• Générer les display lists (GLuint glGenLists(GLsizei range))
• Vérifier l'existance de la display list (glIsList())
• Renseigner une display list (glNewList()/glEndList())
• Effacer une display list ()
• Exécuter une ou plusieurs display list (glCallList()/glCallLists())

- Couleurs et lumières

(Chapitre sur les bases qui peut être un peu compliquer à appréhender !)

• La couleur dans la nature
• Modifier le comportement d'un objet et indiquer type de couleur qui sera utiliser par défaut pour les modifications de couleurs (glColor (), glColorMaterial (face, mode))
• Les sources de lumières
  • Activer/désactiver l'éclairage (glEnable (GL_LIGHTING) et glDisable (GL_LIGHTING))
  • Type de lumière(directionnelle/ponctuelle) et position de la source: glLight()
  • Paramétrer la couleur à émettre suivant le type de couleur (ambient, diffuse ou speculaire) à utiliser
  • Allumez, éteindre les lumières glEnable (GL_LIGHTn) et glDisable (GL_LIGHTn)
• Les normales glNormal()
• L'atténuation de la lumière
• Modèle d'éclairage (glLightModel ())
• Une lumière supplémentaire (glLightModel ())

- Les spots

• Introduction
• cutoff glLight et GL_SPOT_CUTOFF
• Couleurs des objets (glColorMaterial(), glColor(), glMaterial()).
• Direction du spot glLight et GL_SPOT_DIRECTION.
• Qualité d'affichage de la lumière du spot projetée sur les faces:glLight et GL_SPOT_EXPONENT

- Le brouillard

• Principe.
• Création d'un brouillard glFog().
  • définir la couleur du brouillard
  • définir la densité du brouillard
  • Profondeur de champ
  • Formules de calcul utilisées pour générer le brouillard
• Exemple.
• Petit problème concernant les repères dans la matrice de modèle.
• Porté du brouillard
• Qualité du brouillard

- Textures

• Chargement d'une texture
  • Charger un fichier BMP en mémoire
  • Conversion du fichier dans un format RVBA
• Dessiner un cube avec une même texture 2D sur toutes ses faces
  • But à atteindre
  • Revenons à OpenGL...Intialisation des textures (glEnable(), GL_TEXTURE_2D)
  • Paramétrage de la méthode d'agrandissement/rétrécissement de la texture appliquée à un objet (glTexParameter (), GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER)
  • Chargement des textures dans OpenGL (glTexImage2D())
  • Appliquer la texture sur des vertice
    • Associer un texel à un vertex (glTexCoord())
    • Les coordonnées d'un texel
  • Exemple de code
• Dessiner un cube avec une texture 2D différentes par faces
  • But à atteindre
  • Comment faire
  • Création de plusieurs textures (valable à partir d'OpenGL 1.1) (glBindTexture())
  • Utilisation de plusieurs textures (valable à partir d'OpenGL 1.1)
  • Ne plus utiliser de texture
  • Supprimer les textures créées (glDeleteTextures())
  • Exemple de code
• Le mipmapping
  • Petit Problème rencontré
  • Le mipmapping
• Dernières remarques sur les textures
  • Correction perspective glHint()
  • Interaction des couleurs entre un vertex et un texel
  • Priorité au chargement mémoire vidéo
  • Valeur maximum de la taille d'une texture acceptée
  • Retailler une texture

- Blending

• Introduction
• Alpha
• Activation du mélangeur (glEnable (GL_BLEND), glBlendFunc())
  

- Amélioration de la qualité du rendu

• L'anti-aliasing
• Décalage de polygone

- Récupération d'informations utilisées sous OpenGL

• La fonction glGet
• Les variables prépro.
  

Voilà, vous devriez déjà pouvoir bien vous amuser avec ce qui se trouve ici.

Evidemment, toutes les fonctions d'OpenGL ne sont pas présentées dans ces sections. Certaines fonctions (comme le stencil buffer) feront l'objet d'un tout autre chapitre nommé OpenGL avancé. Il y aura aussi des sections revenant un peu plus des fonctions déjà étudié ici...