DEMO OPENGL

---

Commentaire sur cette source (0)
Ajouter un commentaire et/ou une note

Bonjour, ce projet à été réalisé dans le cadre de mon cours Correction de Programmes au Cégep. Le but était de trouver un programme sur cppfrance et d'y apporter des modifications.

Source écrite par Kled: http://www.cppfrance.com/code.aspx?ID=35513


J'ai enlever des DLL pour pouvoir mettre le zip sur cppfrance.
  glut32.dll : http://www.dll-files.com/dllindex/dll-files.shtml?glut32
  fmod.dll   : http://www.dll-files.com/dllindex/dll-files.shtml?fmod

/*
    Auteur: Jean-Sébastien Bilodeau
    Projet: Demo OpenGL
    Date:   2008/05/11

    - Les info sont dans le fichier readme.txt
    - Version initiale du code:
        Auteur: Kled
        Titre:  DOOM LIKE EN OPENGL
        Lien:   http://www.cppfrance.com/code.aspx?ID=35513
*/

#ifdef WIN32
    #include <windows.h>
#endif
#include <GL/openglut_std.h>
#include <string>
#include <cstring>
#include <sstream>
#include <iostream>
using namespace std ;

#include <fmod/fmod.h>//2008/05/04:FMOD v375

#include "Affichage.h"
#include "camera.h"

//Variables générales
GLint nWindowID;
GLboolean pleinEcran=false;
GLint lecran=800,hecran=600;
GLint width = glutGet(GLUT_SCREEN_WIDTH);     //Largeur (pixels)
GLint height= glutGet(GLUT_SCREEN_HEIGHT);    //Hauteur
GLdouble  x=0, y=5, z=92;                     //Position de la camera
GLboolean zoom=false,affText=false;
GLdouble current_time,last_time;

FSOUND_SAMPLE *tir = NULL;
FSOUND_SAMPLE *pla = NULL;
FMUSIC_MODULE *backgrnd = NULL;

//Déclare les objets
Affichage ini;
Camera  fpscam;

//Prototypes des fonctions
GLvoid initFmod ();//2008/05/04: Initialise FMOD
GLvoid delFmod  ();//2008/05/04: Fermeture FMOD

GLvoid keyboard   (GLubyte key, GLint sourisX, GLint sourisY);
GLvoid keyboardUP (GLubyte key, GLint sourisX, GLint sourisY);
GLvoid special    (GLint key,   GLint sourisX, GLint sourisY);
GLvoid specialUP  (GLint key,   GLint sourisX, GLint sourisY);

GLvoid mouse (GLint button, GLint state, GLint sourisX, GLint sourisY);
GLvoid vue   (GLint sourisX, GLint sourisY);
GLvoid attente(GLvoid);

GLvoid display(GLvoid);
GLvoid display1(GLvoid);
GLvoid theDisplay ();

//Convertir n'importe quel type d'objet en string
template<typename T>
string to_string( const T & Value )
{
    //Utiliser un flux de sortie pour créer la chaîne
    ostringstream oss;
    //Écrire la valeur dans le flux
    oss << Value;
    //Renvoyer une string
    return oss.str();
}

//Cette fonction utiliser dans glut ne marche pas directement.
GLvoid reshape (GLint w, GLint h){ini.reshape(w,h,45.0f);}
/*******************************************************************************
                    int main(int argc, char** argv) ;
*******************************************************************************/
GLint main (GLint argc, char* argv[])
{
    string resoPleinEcran;
    GLint rep;

	rep = MessageBox(NULL, "Voulez-vous entrer en mode plein écran?", "Plein écran ?",
						MB_ICONQUESTION | MB_YESNO);
	if(rep==IDYES) pleinEcran = true;

    //Initialiser OpenGL
    glutInit(&argc, argv);
    glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE);

    //Construire la fenêtre
    if (pleinEcran==true)
    {
        //2008/04/06: Récupérer la résolution
        resoPleinEcran  =to_string(width);
        resoPleinEcran +='x';
        resoPleinEcran +=to_string(height);
        resoPleinEcran +=":32";//32bpp Mode

        //glutGameModeString() n'acepte pas de string
        size_t size   = resoPleinEcran.size() + 1;
        char * buffer = new char[ size ];
        strncpy( buffer, resoPleinEcran.c_str(),size );

		glutGameModeString(buffer);
		if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE))
			glutEnterGameMode();// Mode plein écran
    }
    else
    {
		glutInitWindowSize(lecran, hecran);
		glutInitWindowPosition (width/2-lecran/2, 100);
		nWindowID=glutCreateWindow ("Demo OpenGL");//Nom de la fenêtre

        width=lecran;//2008/04/24: Changer les valeurs de la résolution
        height=hecran;
	}

    ini.init1 ();               //Blending
    ini.InitTexture();          //Fonction utilisée pour charger les textures
    ini.init2();                //Blending
    fpscam.initCam(x,y,z);      //Initialiser la camera
    initFmod ();                //Initialisation de FMOD

    glutDisplayFunc(display);   //Monde normal
    glutReshapeFunc(reshape);

    //Gestion du clavier
    glutIgnoreKeyRepeat(true);       //2008/04/27: Désactive la répétition auto
    glutKeyboardFunc   (keyboard);   //Clavier (PRESS)
    glutKeyboardUpFunc (keyboardUP); //2008/04/25: Touche clavier relâcher
    glutSpecialFunc    (special);    //Touche spécial (PRESS)
    glutSpecialUpFunc  (specialUP);  //2008/04/25: Touche spécial relâcher

    //Gestion de la souris
    glutMouseFunc      (mouse);      //Gestion des boutons de la souris
    glutMotionFunc     (vue);        //2008/04/15: Si un bouton de la souris est appuyer
    glutPassiveMotionFunc (vue);     //S'il y a aucun bouton de la souris d'appuyer

    glutIdleFunc (attente);
    glutSetCursor(GLUT_CURSOR_NONE); //GLUT_CURSOR_CROSSHAIR | GLUT_CURSOR_NONE

    glutMainLoop();
    ini.DelTexture(); //2008/05/05: Suprime les textures
    delFmod();        //2008/05/05: Suprime les musiques et ferme FMOD
    return 0;
}
/*******************************************************************************
                    Initialisation de FMOD et des sons
*******************************************************************************/
GLvoid initFmod ()//2008/05/05: Date de création
{
    FSOUND_Init(44100, 32, 0);

    //Son au commencement
    backgrnd = FMUSIC_LoadSong("./Data/Son/backgrnd.mid");//Charger un MIDI
    if (backgrnd == NULL)
        MessageBox(NULL,"Erreur chargement du son:\n./Data/Son/backgrnd.mid","ERROR",MB_OK|MB_ICONEXCLAMATION);
    else
    {
        FMUSIC_PlaySong(backgrnd);              //Jouer un MIDI
        FMUSIC_SetLooping(backgrnd, 1);         //Répéter un MIDI
        FMUSIC_SetMasterVolume(backgrnd, 200);  //Modifier le volume (0 à 256)
    }

    tir = FSOUND_Sample_Load(FSOUND_FREE, "./Data/Son/shot.wav", 0, 0, 0);
    if (tir == NULL)
        MessageBox(NULL,"Erreur chargement du son:\n./Data/Son/shot.wav","ERROR",MB_OK|MB_ICONEXCLAMATION);

    pla = FSOUND_Sample_Load(FSOUND_FREE, "./Data/Son/pla.wav", 0, 0, 0);
    if (tir == NULL)
        MessageBox(NULL,"Erreur chargement du son:\n./Data/Son/pla.wav","ERROR",MB_OK|MB_ICONEXCLAMATION);
}
GLvoid delFmod ()//2008/05/05: Date de création
{
    FSOUND_Sample_Free(tir);    //Libérer le son de la mémoire
    FSOUND_Sample_Free(pla);
    FMUSIC_FreeSong(backgrnd);  //Libérer la musique MIDI
    FSOUND_Close();             //Fermer FMOD
}
/*******************************************************************************
                           Gestion du clavier
*******************************************************************************/
GLvoid keyboard(GLubyte key, GLint sourisX, GLint sourisY)
{
    switch (key)
    {
        //Changement de vue
        case 'v':glutDisplayFunc(display1); break;
        case 'V':glutDisplayFunc(display);  break;

        //Audio pour tir
        case 'z':FSOUND_PlaySound(FSOUND_FREE, tir);break;//PlaySound("shot.wav",NULL,SND_ASYNC);
        case 'x':FSOUND_PlaySound(FSOUND_FREE, pla);break;//PlaySound("pla.wav",NULL,SND_ASYNC);

        //2008/04/07: Mode d'affichage
        case 'b':ini.Brouillard();  break;//Brouillard
        case 'B':glDisable(GL_FOG); break;

        case 'n':ini.initNight(); break;//Faire tomber la nuit
        case 'N':glDisable(GL_LIGHTING);break;

        //case 'm':ini.initSpot();break; //Lumiere spot
        //case 'M':glDisable(GL_LIGHTING);break;

        //2008/05/11:Change l'état de l'affichage du texte
        case '\t':affText=!affText;break;

        //Utilisez les W-S-A-D pour les mouvements.
        case 'w':case 'W':fpscam.avance(); break; //UP
        case 's':case 'S':fpscam.recule(); break; //DOWN
        case 'a':case 'A':fpscam.gauche(); break; //LEFT
        case 'd':case 'D':fpscam.droite(); break; //RIGHT

        case ' ':fpscam.saut();break;             //JUMP

        //2008/05/05: Pour mettre en pause la musique de fond
        case 'p':case 'P':
            if (FMUSIC_GetPaused(backgrnd)) // Si la chanson est en pause
                FMUSIC_SetPaused(backgrnd, 0); // On enlève la pause
            else // Sinon, elle est en cours de lecture
                FMUSIC_SetPaused(backgrnd, 1); // On active la pause
            break;

        //ESCAPE pour quitter
        case 27:if (pleinEcran==false)
                    glutDestroyWindow(nWindowID);//Destruction de la fenêtre
                exit (0);break;

        default:break;
    }
    glutPostRedisplay();
}
//2008/04/25: Quand la toucheUT_UP  est relaché, on arrête le mouvement.
GLvoid keyboardUP (GLubyte key, GLint sourisX, GLint sourisY)
{
    switch (key)
    {
        //Utilisez les UT_UP W-S-A-D pour les mouvements.
        case 'w':case 'W':fpscam.avanceUP(); break; //UP
        case 's':case 'S':fpscam.reculeUP(); break; //DOWN
        case 'a':case 'A':fpscam.gaucheUP(); break; //LEFT
        case 'd':case 'D':fpscam.droiteUP(); break; //RIGHT

        default:break;
    }
    glutPostRedisplay();
}
//2008/04/25: Date de modification
GLvoid special(GLint key,GLint sourisX, GLint sourisY)
{
     switch (key)
     {
         case GLUT_KEY_UP   :fpscam.avance();  break;//UP
         case GLUT_KEY_DOWN :fpscam.recule();  break;//DOWN
         case GLUT_KEY_LEFT :fpscam.gauche();  break;//LEFT
         case GLUT_KEY_RIGHT:fpscam.droite();  break;//RIGHT

		 case GLUT_KEY_F1:glutFullScreen();break;

         default:break;
    }
    glutPostRedisplay();
}
GLvoid specialUP(GLint key,GLint sourisX, GLint sourisY)
{
     switch (key)
     {
         case GLUT_KEY_UP   :fpscam.avanceUP();  break;//UP
         case GLUT_KEY_DOWN :fpscam.reculeUP();  break;//DOWN
         case GLUT_KEY_LEFT :fpscam.gaucheUP();  break;//LEFT
         case GLUT_KEY_RIGHT:fpscam.droiteUP();  break;//RIGHT
         default:break;
    }
    glutPostRedisplay();
}
/*******************************************************************************
                           Gestion de , int sourisX, int sourisYla souris
*******************************************************************************/
GLvoid mouse (GLint button, GLint state, GLint sourisX, GLint sourisY)
{
    //Si l'on appuie sur le bouton gauche
    if ( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN )
        FSOUND_PlaySound(FSOUND_FREE, tir);//PlaySound("shot.wav",NULL,SND_ASYNC);

    //2008/04/25: Zoom si le bouton droit de la souris est appuyer
    if ( state == GLUT_UP && button == GLUT_RIGHT_BUTTON)
        zoom=!zoom;
    else
        if ( state == GLUT_DOWN && button == GLUT_RIGHT_BUTTON)
            zoom=!zoom;

    vue (sourisX,sourisY);
}

GLvoid vue (GLint sourisX, GLint sourisY)
{
    GLdouble dx=sourisX-width/2;
    GLdouble dy=sourisY-height/2;

    fpscam.calculMouvementS(dx,dy);
}
/*******************************************************************************
                         void attente(void) ;
-   Fonction appelée lorsque l'application fait rien.
*******************************************************************************/
GLvoid attente(GLvoid)
{
    //2008/04/16: Centrer la souris
    glutWarpPointer(width/2,height/2) ;

    //2008/04/24: Zoom
    GLboolean reshape=false;
    if (zoom)
    {
        ini.reshape(width,height,25.0f);
        reshape=true;
    }
    else
        //2008/04/28: Pour ne pas faire de reshape à chaque fois
        if (reshape=true)
        {
            ini.reshape(width,height,45.0f);
            reshape=false;
        }

    //2008/04/28: Calculer un délais
    current_time = glutGet(GLUT_ELAPSED_TIME);
    double elapsed_time = current_time - last_time;
    last_time = current_time;

    fpscam.calculMouvement (elapsed_time);
	glutPostRedisplay();//Pour rafraichir l'affichage
}
/*******************************************************************************
                            void display(void);
*******************************************************************************/
GLvoid display(GLvoid)//VUE FPS
{
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glColor3f (1.0, 1.0, 1.0);
  glLoadIdentity();

  //Position et direction de la camera
  fpscam.fixeCam();//gluLookAt

  ini.ciel ();
  ini.theDisplay ();
  if(affText) {
    ini.drawT("Texte Texte Texte", GLUT_BITMAP_HELVETICA_12, 1.0f, 1.0f, 1.0f, 0.03, 0.96 );
    ini.drawT("Texte Texte Texte", GLUT_BITMAP_HELVETICA_12, 1.0f, 1.0f, 1.0f, 0.03, 0.93 );
  }

  ini.drawT("+", GLUT_BITMAP_HELVETICA_18, 1.0f, 1.0f, 1.0f, 0.5, 0.5 );//2008/05/11: Viseur
  glutSwapBuffers();
}
/*******************************************************************************
                          void display1(void);
*******************************************************************************/
GLvoid display1(GLvoid)// VUE DU CIEL
{
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glColor3f (1.0, 1.0, 1.0);
  glLoadIdentity();
  gluLookAt (0.0, 95.0, 150.0f, 0.0, 0.0,40.0, 0.0, 1.0, 0.0);

  ini.theDisplay();
  if(affText) {
    ini.drawT("Texte Texte Texte", GLUT_BITMAP_HELVETICA_12, 1.0f, 1.0f, 1.0f, 0.03, 0.96 );
    ini.drawT("Texte Texte Texte", GLUT_BITMAP_HELVETICA_12, 1.0f, 1.0f, 1.0f, 0.03, 0.935 );
  }

  glutSwapBuffers();
}

Pour finir, je remercie Kled pour la version initiale du code. Ce code n'est pas  un tutoriel. Donc, si vous ne connaissez pas une fonction d'une librairie, n'hésiter surtout pas pour faire une petite recherche sur Google.

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

• LEORACING: JEU DE COURSE MULTIJOUEUR
• JEU LABYRINTHE INTELLIGENCE ARTIFICIELLE
• GESTION DE NOTE AVEC GRAPHIQUE
• INTRO VERSION OPENGL 2D (+EXOTIC MODULE PLAYER)
• MULTITEXTURING ET SHADER

• GESTION DE NOTE AVEC GRAPHIQUE
• SYSTÈME SOLAIRE OPEN GL AVEC BIBLIOTHÈQUE GLUT : 5 PLANETES / LUMIÈRES / ESPACE
• ATTRACTEURS DE FAMILLES DE CONTRACTIONS EN ÉCRAN DE VEILLE
• UNE MINI INTRO (OPENGL + MINIFMOD)
• SUDOKU EN C++ OPENGL, GLUT ET GLUI.