DEMO OPENGL

/*
    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();
}