TUTORIAL OPENGL ET GLUT EN C

/*
  Name: tutorialAnimation
  Author: Algex
  Date: 18/06/06 13:24
  Description: un petit tuto pour l'apprentissage d'OpenGL avec GLUT
*/


///////////////////////////    LES INCLUDES    ////////////////////////////////////////////////////////
                                                                                                     //  
                                                                                                     //
#include <stdio.h>                                                                                   //
#include <stdlib.h>                                                                                  //
                                                                                                     //
#include <windows.h>/*Microsoft Windows requiert l'insertion de windows.h juste avant gl.h et glu.h  //
car certaines macros utilisées en internes dans la version Microsoft Windows de gl.h et glu.h sont   //
définies dans windows.h*/                                                                            //
                                                                                                     //
#include <GL/glut.h>//GL/glut.h contient déjà gl.h et glu.h mais bon c'est juste pour vous montrer   //
                                                                                                     //
///////////////////////////////////////////////////////////////////////////////////////////////////////


//on crée une variable globale qui va nous servir pour la rotation 
static GLfloat spin = 0.0;


/////////////////////////////   LES FONCIONS   /////////////////////////////////////////////////////////


//--Fonction d'initialisation d'OpenGL--//
void init(void)
{
     /*routine permettant de définir la couleur de vidage qui prend comme paramètre les composants
     rouge, vert, bleu de la couleur plus la valeur alpha. En l'occurence, nous mettons un fond noir non transparent*/
     glClearColor(0.0, 0.0, 0.0, 0.0); 
     
     /*routine qui définit le modèle de degradé (lissé ou pas), le paramètre peut prendre la valeur GL_SMOOTH(valeur par défaut)
     ou GL_FLAT*/
     glShadeModel(GL_FLAT);

}

//--fonction d'affichage--//
void display(void)
{
     /*on attribut aux tampons spécifiés leur valeur de vidage en cours*/
     glClear(GL_COLOR_BUFFER_BIT);
     
     /*On fait descendre d'un niveau les matrices de tranformation*/
     glPushMatrix();
     
     /*on fait une rotation pour tout ce qui suit en utilisant le spin avec la fonction glRotate*(). la lettre f
     veut dire que le nombre sera un float*/
     glRotatef(spin, 0.0, 0.0, 1.0);
     
     /*on fait une couleur pour tout ce qui suit avec la fonction glColor*(). la nombre 3 veut dire
     que la fonction prendra 3 paramètre et la lettre f veut dire que ce sont des nombres float (les trois paramètres sont 
     les composants rouge, vert et bleu de la couleur)*/
     glColor3f(1.0, 1.0, 1.0);
     
     /*on crée un rectangle*/
     glRectf(-25.0, -25.0, 25.0, 25.0);
     
     /*on rejette la matrice de la pile, ce qui en détruit le contenu (toutes les modifications apportées précédemment sont annulées)*/
     glPopMatrix();
     
     /*on échange les tampons grâce à GLUT (un tampons est affiché pendant que l'autre se forme ce qui permet 
     d'avoir des images entièrement dessinées à l'affichage)*/
     glutSwapBuffers();
     
}

//--fonction pour le redimensionnement--//
void reshape(int w, int h)
{
     /*Definit un rectangle de pixels dans laquelle l'image finale sera placée.
     Les 2 premiers paramètres sont les coordonnées de l'angle inférieur gauche du cadrage
     et les 2 derniers spécifient sa longueur et sa largeur*/ 
     glViewport(0, 0, (GLsizei) w, (GLsizei) h);
     
     //on se met en mode projection (matrice projection)
     glMatrixMode(GL_PROJECTION);
     
     //on positionne la matrice actuellement modifiable sur la matrice d'identité
     glLoadIdentity();
     
     /*on crée une matrice pour un volume visionné parallèle en perspective cavalière
     et on multiplie la matrice active par celle-ci.*/
     glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
     
     /* On se place sur la matrice de visualisation de modèles
     */
     glMatrixMode(GL_MODELVIEW);
     
     //on positionne la matrice actuellement modifiable (matrice de visualisation) sur la matrice d'identité
     glLoadIdentity();
}

//--la fonction de rotation--//
void spinDisplay(void)
{
     //on tourne vers la droite
     spin += 2;
                         
     //si le spin est plus grand que 360 degrés...
     if (spin > 360)           
          
          //...on enlève 360 pour que se soit un angle normal
          spin-=360.0;
    
    //fonction permettant de raffraichir l'image avec les changements 
    glutPostRedisplay();      
}


//--fonction de gestion de la souris--//
void mouse(int button, int state, int x, int y)     
{
     /*on regarde quel bouton est appuyé*/
     switch(button)
     {     
           //si il y a un evenement concernant le bouton gauche...
           case GLUT_LEFT_BUTTON:
                
                //..et si cet evenement est un clic...
                if (state == GLUT_DOWN)
                
                //on fait tourner le carré vers la droite grace a la fonction spinDisplay()
                glutIdleFunc(spinDisplay);
           break;
                
                
           //si il y a un evenement concernant le bouton du centre...
           case GLUT_RIGHT_BUTTON:
                
                //..et si cet evenement est un clic...
                if (state == GLUT_DOWN)
                
                //on arrete de faire touner le carré, c'est à dire que la fonction de callback (de rappel)
                // spinDisplay est annulée (on arrete de la rappeler)
                glutIdleFunc(NULL);
           break;
                
     }
}
                


//////////////////////////// LA MAIN ///////////////////////////////////////

int main(int argc, char **argv)
{
    //on initialise glut
    glutInit(&argc, argv);   
    
    //on spécifie l'emploi du modèle chromatique et du double tampon
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    
    //on spécifie la taille de la fenêtre
    glutInitWindowSize(250, 250);
    
    //on spécifie la position de la fenêtre
    glutInitWindowPosition(100, 100);
    
    //on crée une fenêtre
    glutCreateWindow(argv[0]);
    
    //on initialise
    init();
    
    ////////////// FONCTIONS DE CALLBACKS ////////////////////////
    
    //
    // Les fonctions de callbacks sont des fonctions que le programmeur va spécifier pour
    // la lier à un événement (clic, touche appuyée, redimensionnement, etc).
    //
    
    //on fait une fonction d'affichage de la scène
    glutDisplayFunc(display);
    
    //on fait une fonction de redimensionnement
    glutReshapeFunc(reshape);
    
    //on fait une fonction pour la souris
    glutMouseFunc(mouse);
    
    // boucle infinie d'affichage
    glutMainLoop();
    
    return 0;
}