Merge branch 'import/cube-world'

! Can't build !

cubeWorld/.gitignore

@@ -0,0 +1 @@
+bin/

cubeWorld/CamControl/Camera.cpp

@@ -0,0 +1,195 @@
+#include "Camera.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+using namespace glm;
+
+
+// Constructeurs
+Camera::Camera()
+: m_phi(0.0), m_theta(0.0), m_orientation(), m_axeVertical(0, 0, 1), m_deplacementLateral(), m_deplacementLineaire(),
+m_position(), m_pointCible(), m_sensibilite(0.0), m_vitesse(0.0), m_vol(false)
+{
+
+}
+
+
+Camera::Camera(glm::vec3 position, glm::vec3 pointCible, glm::vec3 axeVertical, float sensibilite, float vitesse)
+: m_phi(0.0), m_theta(0.0), m_orientation(),
+m_axeVertical(axeVertical), m_deplacementLateral(), m_deplacementLineaire(),
+m_position(position), m_pointCible(pointCible),
+m_sensibilite(sensibilite), m_vitesse(vitesse), m_vol(false)
+{
+    // Actualisation du point ciblé
+    setPointcible(pointCible);
+}
+
+// Destructeur
+Camera::~Camera()
+{}
+
+
+// Méthodes
+void Camera::orienter(float xRel, float yRel)
+{
+    // Récupération des angles
+    m_phi -= yRel * m_sensibilite;
+    m_theta -= xRel * m_sensibilite;
+
+    // Limitation de l'angle phi
+    if(m_phi > 89.0)
+        m_phi = 89.0;
+    else if(m_phi < -89.0)
+        m_phi = -89.0;
+
+    // Conversion des angles en radian
+    float phiRadian = m_phi * M_PI / 180;
+    float thetaRadian = m_theta * M_PI / 180;
+
+    // Si l'axe vertical est l'axe X
+    if(m_axeVertical.x == 1.0)
+    {
+        // Calcul des coordonnées sphériques
+        m_orientation.x = sin(phiRadian);
+        m_orientation.y = cos(phiRadian) * cos(thetaRadian);
+        m_orientation.z = cos(phiRadian) * sin(thetaRadian);
+    }
+
+    // Si c'est l'axe Y
+    else if(m_axeVertical.y == 1.0)
+    {
+        // Calcul des coordonnées sphériques
+        m_orientation.x = cos(phiRadian) * sin(thetaRadian);
+        m_orientation.y = sin(phiRadian);
+        m_orientation.z = cos(phiRadian) * cos(thetaRadian);
+    }
+
+    // Sinon c'est l'axe Z
+    else
+    {
+        // Calcul des coordonnées sphériques
+        m_orientation.x = cos(phiRadian) * cos(thetaRadian);
+        m_orientation.y = cos(phiRadian) * sin(thetaRadian);
+        m_orientation.z = sin(phiRadian);
+    }
+
+    // Calcul de la normale
+    m_deplacementLateral = normalize(cross(m_axeVertical, m_orientation));
+
+    // Calcul vecteur pour avancer
+    m_deplacementLineaire = normalize(cross(m_deplacementLateral, m_axeVertical));
+
+    // Calcul du point ciblé pour OpenGL
+    m_pointCible = m_position + m_orientation;
+}
+
+
+void Camera::deplacer(Input const &input)
+{
+    // Gestion de l'orientation
+    if (input.getMainXRel()!=0 || input.getMainYRel()!=0)
+        orienter(input.getMainXRel(), input.getMainYRel());
+
+    // Avancée de la caméra
+    if (m_vol)
+        m_position = m_position - m_orientation * (m_vitesse * input.getMainXMove());
+    else
+        m_position = m_position - m_deplacementLineaire * (m_vitesse * input.getMainXMove());
+
+    // Déplacement lateral
+    m_position = m_position - m_deplacementLateral * (m_vitesse * input.getMainYMove());
+
+    // Calcul du point ciblé pour OpenGL
+    m_pointCible = m_position + m_orientation;
+}
+
+
+void Camera::lookAt(glm::mat4 &modelview)
+{
+    // Actualisation de la vue dans la matrice
+    modelview = glm::lookAt(m_position, m_pointCible, m_axeVertical);
+}
+
+
+// Getters et Setters
+
+void Camera::setPointcible(glm::vec3 pointCible)
+{
+    // Calcul du vecteur orientation
+    m_orientation = m_pointCible - m_position;
+    m_orientation = normalize(m_orientation);
+
+    // Si l'axe vertical est l'axe X
+    if(m_axeVertical.x == 1.0)
+    {
+        // Calcul des angles
+        m_phi = asin(m_orientation.x);
+        m_theta = acos(m_orientation.y / cos(m_phi));
+        if(m_orientation.y < 0)
+            m_theta *= -1;
+    }
+
+    // Si c'est l'axe Y
+    else if(m_axeVertical.y == 1.0)
+    {
+        // Calcul des angles
+        m_phi = asin(m_orientation.y);
+        m_theta = acos(m_orientation.z / cos(m_phi));
+        if(m_orientation.z < 0)
+            m_theta *= -1;
+    }
+
+    // Sinon c'est l'axe Z
+    else
+    {
+        // Calcul des angles
+        m_phi = asin(m_orientation.x);
+        m_theta = acos(m_orientation.z / cos(m_phi));
+
+        if(m_orientation.z < 0)
+            m_theta *= -1;
+    }
+
+    // Conversion en degrés
+    m_phi = m_phi * 180 / M_PI;
+    m_theta = m_theta * 180 / M_PI;
+}
+
+
+void Camera::setPosition(glm::vec3 position)
+{
+    // Mise à jour de la position
+    m_position = position;
+
+    // Actualisation du point ciblé
+    m_pointCible = m_position + m_orientation;
+}
+
+
+float Camera::getSensibilite() const
+{
+    return m_sensibilite;
+}
+
+
+float Camera::getVitesse() const
+{
+    return m_vitesse;
+}
+
+
+void Camera::setSensibilite(float sensibilite)
+{
+    m_sensibilite = sensibilite;
+}
+
+
+void Camera::setVitesse(float vitesse)
+{
+    m_vitesse = vitesse;
+}
+
+void Camera::setVol(bool activation)
+{
+    m_vol = activation;
+}

cubeWorld/CamControl/Camera.h

@@ -0,0 +1,63 @@
+#ifndef DEF_CAMERA
+#define DEF_CAMERA
+
+
+///Jovian
+///Adaptation pour InputAndJoy
+///Dernière modif : plaqué au sol (m_linear)
+
+// Includes GLM
+#include <glm/glm.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+
+// Autres includes
+#include "Input.h"
+
+
+// Classe
+class Camera
+{
+    public:
+
+    Camera();
+    Camera(glm::vec3 position, glm::vec3 pointCible, glm::vec3 axeVertical, float sensibilite, float vitesse);
+    ~Camera();
+
+    void orienter(float xRel, float yRel);
+    void deplacer(Input const &input);
+    void lookAt(glm::mat4 &modelview);
+
+    void setPointcible(glm::vec3 pointCible);
+    void setPosition(glm::vec3 position);
+
+    float getSensibilite() const;
+    float getVitesse() const;
+
+    void setSensibilite(float sensibilite);
+    void setVitesse(float vitesse);
+
+    void setVol(bool activation);
+
+
+    private:
+
+    float m_phi;
+    float m_theta;
+    glm::vec3 m_orientation;
+
+    glm::vec3 m_axeVertical;
+    glm::vec3 m_deplacementLateral;
+    glm::vec3 m_deplacementLineaire;
+
+    glm::vec3 m_position;
+    glm::vec3 m_pointCible;
+
+    float m_sensibilite;
+    float m_vitesse;
+    bool m_vol;
+};
+
+#endif

cubeWorld/CamControl/Input.cpp

@@ -0,0 +1,224 @@
+#include "Input.h"
+
+
+// Constructeur et Destructeur
+Input::Input()
+: m_x(0), m_y(0), m_xRel(0), m_yRel(0),
+m_avancer(SDL_SCANCODE_UP), m_reculer(SDL_SCANCODE_DOWN), m_droite(SDL_SCANCODE_RIGHT), m_gauche(SDL_SCANCODE_LEFT),
+m_terminer(false), m_relativeMouse(false), m_window(0), m_windowHalfHeight(0), m_windowHalfWidth(0)
+{
+    // Initialisation du tableau m_touches[]
+    for(int i(0); i < SDL_NUM_SCANCODES; i++)
+        m_touches[i] = false;
+
+    // Initialisation du tableau m_boutonsSouris[]
+    for(int i(0); i < 8; i++)
+        m_boutonsSouris[i] = false;
+}
+
+
+Input::~Input()
+{}
+
+
+// Méthodes
+void Input::updateEvenements()
+{
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
+        {
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.scancode] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.scancode] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
+            case SDL_MOUSEMOTION:
+                if (m_relativeMouse)
+                {
+                    m_xRel = m_evenements.motion.x-m_windowHalfWidth;
+                    m_yRel = m_evenements.motion.y-m_windowHalfHeight;
+                }
+                else
+                {
+                    m_x = m_evenements.motion.x;
+                    m_y = m_evenements.motion.y;
+                    m_xRel = m_evenements.motion.xrel;
+                    m_yRel = m_evenements.motion.yrel;
+                }
+
+            break;
+
+            // Cas de la fermeture de la fenêtre
+            case SDL_WINDOWEVENT:
+                if(m_evenements.window.event == SDL_WINDOWEVENT_CLOSE)
+                    m_terminer = true;
+            break;
+
+
+            default:
+            break;
+        }
+    }
+
+    // Pour éviter que la souris se barre en mode relative, on la "warp"
+    if (m_relativeMouse)
+         SDL_WarpMouseInWindow(m_window,m_windowHalfWidth,m_windowHalfHeight);
+}
+
+
+bool Input::terminer() const
+{
+    return m_terminer;
+}
+
+
+void Input::afficherPointeur(bool reponse) const
+{
+    if(reponse)
+        SDL_ShowCursor(SDL_ENABLE);
+
+    else
+        SDL_ShowCursor(SDL_DISABLE);
+}
+
+
+void Input::capturerPointeur(bool reponse)
+{
+    m_relativeMouse = reponse;
+}
+
+
+
+// Getters
+
+bool Input::getTouche(const SDL_Scancode touche) const
+{
+    return m_touches[touche];
+}
+
+
+bool Input::getBoutonSouris(const Uint8 bouton) const
+{
+    return m_boutonsSouris[bouton];
+}
+
+
+bool Input::mouvementSouris() const
+{
+    if(m_xRel == 0 && m_yRel == 0)
+        return false;
+
+    else
+        return true;
+}
+
+
+// Getters concernant la position du curseur
+
+int Input::getX() const
+{
+    return m_x;
+}
+
+int Input::getY() const
+{
+    return m_y;
+}
+
+int Input::getXRel() const
+{
+    return m_xRel;
+}
+
+int Input::getYRel() const
+{
+    return m_yRel;
+}
+
+void Input::setWindow(SDL_Window* activWindow)
+{
+    // Attributio directe
+    m_window = activWindow;
+
+    // Détermination de l'endroit de capture du pointeur
+    SDL_GetWindowSize(activWindow, &m_windowHalfWidth, &m_windowHalfHeight);
+    m_windowHalfWidth /= 2;
+    m_windowHalfHeight /=2;
+}
+
+void Input::setMoveKeys(SDL_Scancode avancer, SDL_Scancode reculer, SDL_Scancode droite, SDL_Scancode gauche)
+{
+    m_avancer = avancer;
+    m_reculer = reculer;
+    m_droite = droite;
+    m_gauche = gauche;
+}
+
+float Input::getMainXRel() const
+{
+    return (float) m_xRel;
+}
+
+float Input::getMainYRel() const
+{
+    return (float) m_yRel;
+}
+
+float Input::getMainXMove() const
+{
+    // Avancée de la caméra
+    if(getTouche(m_avancer))
+    {
+        return -1.0;
+    }
+
+    // Recul de la caméra
+    if(getTouche(m_reculer))
+    {
+        return 1.0;
+    }
+
+    // Caméra immobile
+    return 0.0;
+}
+
+float Input::getMainYMove() const
+{
+    // Déplacement vers la gauche
+    if(getTouche(m_gauche))
+    {
+        return -1.0;
+    }
+
+    // Déplacement vers la droite
+    if(getTouche(m_droite))
+    {
+        return 1.0;
+    }
+
+    // Caméra immobile
+    return 0.0;
+}

cubeWorld/CamControl/Input.h

@@ -0,0 +1,68 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+///Jovian
+///Adaptation pour InputAndJoy
+
+// Include
+#include <SDL2/SDL.h>
+
+
+// Classe
+class Input
+{
+    public:
+
+    Input();
+    ~Input();
+
+    virtual void updateEvenements();
+    bool terminer() const;
+    void afficherPointeur(bool reponse) const;
+    void capturerPointeur(bool reponse);
+
+    bool getTouche(const SDL_Scancode touche) const;
+    bool getBoutonSouris(const Uint8 bouton) const;
+    bool mouvementSouris() const;
+
+    int getX() const;
+    int getY() const;
+
+    int getXRel() const;
+    int getYRel() const;
+
+    void setWindow(SDL_Window* activWindow);
+    void setMoveKeys(SDL_Scancode avancer, SDL_Scancode reculer, SDL_Scancode droite, SDL_Scancode gauche);
+
+    virtual float getMainXRel() const;
+    virtual float getMainYRel() const;
+    virtual float getMainXMove() const;
+    virtual float getMainYMove() const;
+
+
+    protected:
+
+    SDL_Event m_evenements;
+    bool m_touches[SDL_NUM_SCANCODES];
+    bool m_boutonsSouris[8];
+
+    int m_x;
+    int m_y;
+    int m_xRel;
+    int m_yRel;
+
+    SDL_Scancode m_avancer;
+    SDL_Scancode m_reculer;
+    SDL_Scancode m_droite;
+    SDL_Scancode m_gauche;
+
+    bool m_terminer;
+    bool m_relativeMouse;
+
+    SDL_Window* m_window;
+    int m_windowHalfHeight;
+    int m_windowHalfWidth;
+};
+
+#endif
+

cubeWorld/CamControl/InputAndJoy.cpp

@@ -0,0 +1,183 @@
+#include "InputAndJoy.h"
+
+InputAndJoy::InputAndJoy()
+: m_manette(0), m_nbAxes(0), m_nbBoutons(0), m_controleurType(0), m_seuil(3600)
+{
+    // Démarrage du joystick
+    if (SDL_InitSubSystem(SDL_INIT_JOYSTICK)<0)
+    {
+        std::cout << "Problème lors de l'initialisation du matériel pour les manettes : "<<SDL_GetError()<< std::endl;
+    }
+    else
+    {
+        // Ouverture du joystick
+        SDL_JoystickEventState(SDL_ENABLE);
+        m_manette = SDL_JoystickOpen(0);
+        if (m_manette == NULL)
+        {
+            std::cout << "Manette non démarrée : " << SDL_GetError() << std::endl;
+            setMainControleur(CLAVIER_SOURIS);
+        }
+        else
+        {
+            setMainControleur(MANETTE);
+            // Détermination de la valeur des attributs
+            m_nbAxes = SDL_JoystickNumAxes(m_manette);
+            m_nbBoutons = SDL_JoystickNumButtons(m_manette);
+            for (int i(0); i<m_nbAxes; i++)
+                m_axeValue.push_back(0);
+            for (int i(0); i<m_nbBoutons; i++)
+                m_boutonValue.push_back(false);
+        }
+    }
+}
+
+InputAndJoy::~InputAndJoy()
+{
+    //SDL_JoystickClose(m_manette);
+}
+
+void InputAndJoy::updateEvenements()
+{
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
+        {
+        /// Evenements clavier et souris
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.scancode] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.scancode] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
+            case SDL_MOUSEMOTION:
+                if (m_relativeMouse)
+                {
+                    m_xRel = m_evenements.motion.x-m_windowHalfWidth;
+                    m_yRel = m_evenements.motion.y-m_windowHalfHeight;
+                }
+                else
+                {
+                    m_x = m_evenements.motion.x;
+                    m_y = m_evenements.motion.y;
+                    m_xRel = m_evenements.motion.xrel;
+                    m_yRel = m_evenements.motion.yrel;
+                }
+
+            break;
+
+            // Cas de la fermeture de la fenêtre
+            case SDL_WINDOWEVENT:
+                if(m_evenements.window.event == SDL_WINDOWEVENT_CLOSE)
+                    m_terminer = true;
+            break;
+
+        /// Evenements joystick
+            case SDL_JOYAXISMOTION:
+                if (m_evenements.jaxis.value>m_seuil || m_evenements.jaxis.value<-m_seuil)
+                    m_axeValue[m_evenements.jaxis.axis] = m_evenements.jaxis.value;
+                else
+                    m_axeValue[m_evenements.jaxis.axis] = 0;
+                break;
+            //case boutons
+
+            default:
+            break;
+        }
+    }
+
+    // Pour éviter que la souris se barre en mode relative, on la "warp"
+    if (m_relativeMouse)
+         SDL_WarpMouseInWindow(m_window,m_windowHalfWidth,m_windowHalfHeight);
+}
+
+int InputAndJoy::getAxeValue(const Uint8 axeID) const
+{
+    if (axeID<m_nbAxes)
+        return m_axeValue[axeID];
+    else
+        std::cout << "Axe numéro "<<axeID<<" non-éxistant." << std::endl;
+    return -1;
+}
+
+bool InputAndJoy::getBoutonPad(const Uint8 bouton) const
+{
+    if (bouton<m_nbBoutons)
+        return m_boutonValue[bouton];
+    else
+        std::cout << "Bouton numéro "<<bouton<<" non-éxistant." << std::endl;
+    return false;
+}
+
+void InputAndJoy::setMainControleur(int type)
+{
+    if (type == CLAVIER_SOURIS || type == MANETTE)
+        if (m_manette!=0 || type!=MANETTE)
+            m_controleurType = type;
+}
+
+float InputAndJoy::getMainXRel() const
+{
+    // Clavier
+    if (m_controleurType == CLAVIER_SOURIS)
+        return Input::getMainXRel();
+    // Manette
+        return (float)m_axeValue[3]/3000.0f;
+
+}
+
+float InputAndJoy::getMainYRel() const
+{
+
+    // Clavier
+    if (m_controleurType == CLAVIER_SOURIS)
+        return Input::getMainYRel();
+    // Manette
+        return (float)m_axeValue[4]/3000.0f;
+
+}
+
+float InputAndJoy::getMainXMove() const
+{
+
+    // Clavier
+    if (m_controleurType == CLAVIER_SOURIS)
+        return Input::getMainXMove();
+    // Manette
+        return (float)m_axeValue[1]/30000.0f;
+
+}
+
+float InputAndJoy::getMainYMove() const
+{
+
+    // Clavier
+    if (m_controleurType == CLAVIER_SOURIS)
+        return Input::getMainYMove();
+    // Manette
+        return (float)m_axeValue[0]/30000.0f;
+
+}
+
+

cubeWorld/CamControl/InputAndJoy.h

@@ -0,0 +1,51 @@
+#ifndef INPUTANDJOY_H_INCLUDED
+#define INPUTANDJOY_H_INCLUDED
+
+
+///Jovian
+///Adaptation pour InputAndJoy
+
+// Include
+#include <SDL2/SDL.h>
+#include <iostream>
+#include <vector>
+#include "Input.h"
+
+//Enum
+#define CLAVIER_SOURIS 1
+#define MANETTE 2
+
+// Classe
+class InputAndJoy : public Input
+{
+    public:
+
+    InputAndJoy();
+    ~InputAndJoy();
+
+    virtual void updateEvenements();
+
+    int getAxeValue(const Uint8 axeID) const;
+    bool getBoutonPad(const Uint8 bouton) const;
+
+    void setMainControleur(int type);
+
+    virtual float getMainXRel() const;
+    virtual float getMainYRel() const;
+    virtual float getMainXMove() const;
+    virtual float getMainYMove() const;
+
+
+    private:
+
+    SDL_Joystick* m_manette;
+    int m_nbAxes;
+    int m_nbBoutons;
+    int m_controleurType;
+    int const m_seuil;
+
+    std::vector<int> m_axeValue;
+    std::vector<bool> m_boutonValue;
+};
+
+#endif // INPUTANDJOY_H_INCLUDED

cubeWorld/Cubes/Caisse.cpp

@@ -0,0 +1,116 @@
+#include "Caisse.h"
+
+// Permet d'éviter la ré-écriture du namespace glm::
+using namespace glm;
+
+// Constructeur et Destructeur
+Caisse::Caisse(float taille, std::string const vertexShader,std::string const fragmentShader, std::string const texture)
+: Cube(taille, vertexShader, fragmentShader), m_texture(), m_tailleCoordTextureBytes(72 * sizeof(float))
+{
+    // Chargement de la texture
+    m_texture.charger(texture);
+
+    // Coordonnées de texture temporaires
+    float coordTextureTmp[] = {0, 0,   1, 0,   1, 1,     // Face 1
+                               0, 0,   0, 1,   1, 1,     // Face 1
+                               0, 0,   1, 0,   1, 1,     // Face 2
+                               0, 0,   0, 1,   1, 1,     // Face 2
+                               0, 0,   1, 0,   1, 1,     // Face 3
+                               0, 0,   0, 1,   1, 1,     // Face 3
+                               0, 0,   1, 0,   1, 1,     // Face 4
+                               0, 0,   0, 1,   1, 1,     // Face 4
+                               0, 0,   1, 0,   1, 1,     // Face 5
+                               0, 0,   0, 1,   1, 1,     // Face 5
+                               0, 0,   1, 0,   1, 1,     // Face 6
+                               0, 0,   0, 1,   1, 1};    // Face 6
+
+
+    // Copie des valeurs dans le tableau final
+    for(int i (0); i < 72; i++)
+        m_coordTexture[i] = coordTextureTmp[i];
+}
+
+Caisse::~Caisse()
+{}
+
+// Méthodes
+void Caisse::charger()
+{
+    /// Chargement Vertex Buffer Object
+    // Destruction d'un éventuel ancien VBO
+    if(glIsBuffer(m_vboID) == GL_TRUE)
+        glDeleteBuffers(1, &m_vboID);
+
+    // Génération de l'ID
+    glGenBuffers(1, &m_vboID);
+
+    // Verrouillage du VBO
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+        // Allocation de la mémoire vidéo
+        glBufferData(GL_ARRAY_BUFFER, m_tailleVerticesBytes + m_tailleCoordTextureBytes, 0, GL_STATIC_DRAW);
+
+        // Transfert des données
+        glBufferSubData(GL_ARRAY_BUFFER, 0, m_tailleVerticesBytes, m_vertices);
+        glBufferSubData(GL_ARRAY_BUFFER, m_tailleVerticesBytes, m_tailleCoordTextureBytes, m_coordTexture);
+
+    // Déverrouillage de l'objet
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    /// Chargement Vertex Array Object
+    // Destruction d'un éventuel ancien VAO
+    if(glIsVertexArray(m_vaoID) == GL_TRUE)
+        glDeleteVertexArrays(1, &m_vaoID);
+
+    // Génération de l'ID du VAO
+    glGenVertexArrays(1, &m_vaoID);
+
+    // Verrouillage du VAO
+    glBindVertexArray(m_vaoID);
+
+        // Verrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+            // Accès aux vertices dans la mémoire vidéo
+            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+            glEnableVertexAttribArray(0);
+
+            // Accès aux coordonnées de texture dans la mémoire vidéo
+            glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(m_tailleVerticesBytes));
+            glEnableVertexAttribArray(2);
+
+        // Déverrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+
+    // Déverrouillage du VAO
+    glBindVertexArray(0);
+}
+
+void Caisse::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+    glUseProgram(m_shader.getProgramID());
+
+        // Verrouillage du VAO
+        glBindVertexArray(m_vaoID);
+
+            // Envoi des matrices
+            glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "projection"), 1, GL_FALSE, value_ptr(projection));
+            glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "modelview"), 1, GL_FALSE, value_ptr(modelview));
+
+            // Verrouillage de la texture
+            glBindTexture(GL_TEXTURE_2D, m_texture.getID());
+
+            // Rendu
+            glDrawArrays(GL_TRIANGLES, 0, 36);
+
+            // Déverrouillage de la texture
+            glBindTexture(GL_TEXTURE_2D, 0);
+
+        // Déverrouillage du VAO
+        glBindVertexArray(0);
+
+    // Désactivation du shader
+    glUseProgram(0);
+}

cubeWorld/Cubes/Caisse.h

@@ -0,0 +1,28 @@
+#ifndef DEF_CAISSE
+#define DEF_CAISSE
+
+// Includes
+#include "Cube.h"
+#include "Texture.h"
+#include <string>
+
+// Classe Caisse
+class Caisse : public Cube
+{
+    public:
+
+    Caisse(float taille, std::string const vertexShader, std::string const fragmentShader, std::string const texture);
+    ~Caisse();
+
+    void charger();
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    private:
+
+    Texture m_texture;
+    float m_coordTexture[72];
+    int m_tailleCoordTextureBytes;
+};
+
+#endif

cubeWorld/Cubes/Cube.cpp

@@ -0,0 +1,161 @@
+#include "Cube.h"
+
+// Permet d'éviter la ré-écriture du namespace glm::
+using namespace glm;
+
+// Constructeur et Destructeur
+Cube::Cube(float taille, std::string const vertexShader, std::string const fragmentShader)
+: m_shader(vertexShader, fragmentShader), m_vboID(0), m_tailleVerticesBytes(108 * sizeof(float)), m_tailleCouleursBytes(108 * sizeof(float)), m_vaoID(0)
+{
+    // Chargement du shader
+    m_shader.charger();
+
+    // Division de la taille
+    taille /= 2;
+
+    // Vertices temporaires
+    float verticesTmp[] = {-taille, -taille, -taille,   taille, -taille, -taille,   taille, taille, -taille,     // Face 1
+                           -taille, -taille, -taille,   -taille, taille, -taille,   taille, taille, -taille,     // Face 1
+                           taille, -taille, taille,   taille, -taille, -taille,   taille, taille, -taille,       // Face 2
+                           taille, -taille, taille,   taille, taille, taille,   taille, taille, -taille,         // Face 2
+                           -taille, -taille, taille,   taille, -taille, taille,   taille, -taille, -taille,      // Face 3
+                           -taille, -taille, taille,   -taille, -taille, -taille,   taille, -taille, -taille,    // Face 3
+                           taille, -taille, taille,   -taille, -taille, taille,   -taille, taille, taille,        // Face 4
+                           taille, -taille, taille,   taille, taille, taille,   -taille, taille, taille,        // Face 4
+                           -taille, -taille, -taille,   -taille, -taille, taille,   -taille, taille, taille,     // Face 5
+                           -taille, -taille, -taille,   -taille, taille, -taille,   -taille, taille, taille,     // Face 5
+                           -taille, taille, taille,   taille, taille, taille,   taille, taille, -taille,         // Face 6
+                           -taille, taille, taille,   -taille, taille, -taille,   taille, taille, -taille};      // Face 6
+
+    // Couleurs temporaires
+    float couleursTmp[] = {1.0, 0.0, 0.0,   1.0, 0.0, 0.0,   1.0, 0.0, 0.0,           // Face 1
+                           1.0, 0.0, 0.0,   1.0, 0.0, 0.0,   1.0, 0.0, 0.0,           // Face 1
+                           0.0, 1.0, 0.0,   0.0, 1.0, 0.0,   0.0, 1.0, 0.0,           // Face 2
+                           0.0, 1.0, 0.0,   0.0, 1.0, 0.0,   0.0, 1.0, 0.0,           // Face 2
+                           0.0, 0.0, 1.0,   0.0, 0.0, 1.0,   0.0, 0.0, 1.0,           // Face 3
+                           0.0, 0.0, 1.0,   0.0, 0.0, 1.0,   0.0, 0.0, 1.0,           // Face 3
+                           1.0, 0.0, 0.0,   1.0, 0.0, 0.0,   1.0, 0.0, 0.0,           // Face 4
+                           1.0, 0.0, 0.0,   1.0, 0.0, 0.0,   1.0, 0.0, 0.0,           // Face 4
+                           0.0, 1.0, 0.0,   0.0, 1.0, 0.0,   0.0, 1.0, 0.0,           // Face 5
+                           0.0, 1.0, 0.0,   0.0, 1.0, 0.0,   0.0, 1.0, 0.0,           // Face 5
+                           0.0, 0.0, 1.0,   0.0, 0.0, 1.0,   0.0, 0.0, 1.0,           // Face 6
+                           0.0, 0.0, 1.0,   0.0, 0.0, 1.0,   0.0, 0.0, 1.0};          // Face 6
+
+    // Copie des valeurs dans les tableaux finaux
+    for(int i(0); i < 108; i++)
+    {
+        m_vertices[i] = verticesTmp[i];
+        m_couleurs[i] = couleursTmp[i];
+    }
+}
+
+Cube::~Cube()
+{
+    // Destruction du VBO
+    glDeleteBuffers(1, &m_vboID);
+
+    // Destruction du VAO
+    glDeleteVertexArrays(1, &m_vaoID);
+}
+
+// Méthodes
+void Cube::charger()
+{
+    /// Chargement Vertex Buffer Object
+    // Destruction d'un éventuel ancien VBO
+    if(glIsBuffer(m_vboID) == GL_TRUE)
+        glDeleteBuffers(1, &m_vboID);
+
+    // Génération de l'ID
+    glGenBuffers(1, &m_vboID);
+
+    // Verrouillage du VBO
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+        // Allocation de la mémoire vidéo
+        glBufferData(GL_ARRAY_BUFFER, m_tailleVerticesBytes + m_tailleCouleursBytes, 0, GL_STATIC_DRAW);//GL_DYNAMIC_DRAW, GL_STREAM_DRAW
+
+        // Transfert des données
+        glBufferSubData(GL_ARRAY_BUFFER, 0, m_tailleVerticesBytes, m_vertices);
+        glBufferSubData(GL_ARRAY_BUFFER, m_tailleVerticesBytes, m_tailleCouleursBytes, m_couleurs);
+
+    // Déverrouillage de l'objet
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    /// Chargement Vertex Array Object
+    // Destruction d'un éventuel ancien VAO
+    if(glIsVertexArray(m_vaoID) == GL_TRUE)
+        glDeleteVertexArrays(1, &m_vaoID);
+
+    // Génération de l'identifiant du VAO
+    glGenVertexArrays(1, &m_vaoID);
+
+    // Verrouillage du VAO
+    glBindVertexArray(m_vaoID);
+
+        // Verrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+            // Accès aux vertices dans la mémoire vidéo
+            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+            glEnableVertexAttribArray(0);
+
+            // Accès aux couleurs dans la mémoire vidéo
+            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(m_tailleVerticesBytes));
+            glEnableVertexAttribArray(1);
+
+        // Déverrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    // Déverrouillage du VAO
+    glBindVertexArray(0);
+}
+
+void Cube::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+    glUseProgram(m_shader.getProgramID());
+
+        // Verrouillage du VAO
+        glBindVertexArray(m_vaoID);
+
+            // Envoi des matrices
+            glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "projection"), 1, GL_FALSE, value_ptr(projection));
+            glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "modelview"), 1, GL_FALSE, value_ptr(modelview));
+
+            // Rendu
+            glDrawArrays(GL_TRIANGLES, 0, 36);
+
+        // Déverrouillage du VAO
+        glBindVertexArray(0);
+
+    // Désactivation du shader
+    glUseProgram(0);
+}
+
+void Cube::updateVBO(void *donnees, int tailleBytes, int decalage)
+{
+    // Verrouillage du VBO
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+        // Récupération de l'adresse du VBO
+        void *adresseVBO = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+
+        // Si l'adresse retournée est nulle alors on arrête le transfert
+        if(adresseVBO == NULL)
+        {
+            std::cout << "Erreur au niveau de la récupération du VBO" << std::endl;
+            glBindBuffer(GL_ARRAY_BUFFER, 0);
+            return;
+        }
+
+        // Mise à jour des données
+        memcpy((char*)adresseVBO + decalage, donnees, tailleBytes);
+
+        // Annulation du pointeur
+        glUnmapBuffer(GL_ARRAY_BUFFER);
+        adresseVBO = 0;
+
+    // Déverrouillage du VBO
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+}

cubeWorld/Cubes/Cube.h

@@ -0,0 +1,58 @@
+#ifndef DEF_CUBE
+#define DEF_CUBE
+
+// Include Windows
+#ifdef WIN32
+#include <GL/glew.h>
+
+// Include Mac
+#elif __APPLE__
+#define GL3_PROTOTYPES 1
+#include <OpenGL/gl3.h>
+
+// Include UNIX/Linux
+#else
+#define GL3_PROTOTYPES 1
+#include <GL/gl.h>
+#endif
+
+// Includes GLM
+#include <glm/glm.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// Includes
+#include "../Shader.h"
+
+// Macro utile au VBO
+#ifndef BUFFER_OFFSET
+    #define BUFFER_OFFSET(offset) ((char*)NULL + (offset))
+#endif
+
+// Classe Cube
+class Cube
+{
+    public:
+
+    Cube(float taille, std::string const vertexShader, std::string const fragmentShader);
+    ~Cube();
+
+    void charger();
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+    void updateVBO(void *donnees, int tailleBytes, int decalage);
+
+
+    protected:
+
+    Shader m_shader;
+    float m_vertices[108];
+    float m_couleurs[108];
+
+    GLuint m_vboID;
+    int m_tailleVerticesBytes;
+    int m_tailleCouleursBytes;
+    GLuint m_vaoID;
+};
+
+#endif

cubeWorld/Cubes/Texture.cpp

@@ -0,0 +1,157 @@
+#include "Texture.h"
+
+// Constructeur
+Texture::Texture() : m_id(0)
+{
+
+}
+
+// Constructeur de copie
+Texture::Texture(Texture const &textureACopier)
+{
+    //Rechargement de la même texture
+    charger(textureACopier.m_chemin);
+}
+
+// Destructeur
+Texture::~Texture()
+{
+    glDeleteTextures(1, &m_id);
+}
+
+//Opérateur =
+Texture& Texture::operator=(Texture const &textureACopier)
+{
+    //Rechargement de la même texture
+    charger(textureACopier.m_chemin);
+
+    // Retour du pointeur *this
+    return *this;
+}
+
+// Méthodes
+bool Texture::charger(std::string fichierImage)
+{
+    //Attribution fichier image
+    m_chemin = fichierImage;
+
+    //Chargement
+    SDL_Surface* imageInversee = SDL_LoadBMP(fichierImage.c_str());
+    if(imageInversee == 0)
+    {
+        std::cout << "Erreur chargement texture : " << SDL_GetError() << std::endl;
+        return false;
+    }
+
+    //Mettre l'image à l'endroit
+    SDL_Surface* imageSDL = inverserPixels(imageInversee);
+    SDL_FreeSurface(imageInversee);
+    imageInversee = 0;
+
+    // Destruction d'une éventuelle ancienne texture
+    if(glIsTexture(m_id) == GL_TRUE)
+        glDeleteTextures(1, &m_id);
+
+    // Génération de l'ID
+    glGenTextures(1, &m_id);
+
+    // Verrouillage
+    glBindTexture(GL_TEXTURE_2D, m_id);
+
+    // Format de l'image
+    GLenum formatInterne(0);
+    GLenum format(0);
+
+    // Détermination du format et du format interne pour les images à 3 composantes
+    std::cout << "Texture format interne|ordre de l'image "<<fichierImage<<" : ";
+    if(imageSDL->format->BytesPerPixel == 3)
+    {
+        // Format interne
+        formatInterne = GL_RGB;
+        std::cout << "GL_RGB|";
+
+        // Format
+        if(imageSDL->format->Rmask == 0xff){
+            format = GL_RGB;
+            std::cout << "GL_RGB";
+        }
+        else{
+            format = GL_BGR;
+            std::cout << "GL_BGR";
+        }
+    }
+
+    // Détermination du format et du format interne pour les images à 4 composantes
+    else if(imageSDL->format->BytesPerPixel == 4)
+    {
+        // Format interne
+        formatInterne = GL_RGBA;
+        std::cout << "GL_RGBA|";
+
+        // Format
+        if(imageSDL->format->Rmask == 0xff){
+            format = GL_RGBA;
+            std::cout << "GL_RGBA";
+        }
+        else{
+            format = GL_BGRA;
+            std::cout << "GL_BGRA";
+        }
+    }
+
+
+    // Dans les autres cas, on arrête le chargement
+    else
+    {
+        std::cout << "Erreur, format interne de l'image inconnu" ;//<< std::endl;
+        SDL_FreeSurface(imageSDL);
+
+        return false;
+    }
+    std::cout << std::endl;
+
+    // Copie des pixels
+    glTexImage2D(GL_TEXTURE_2D, 0, formatInterne, imageSDL->w, imageSDL->h, 0, format, GL_UNSIGNED_BYTE, imageSDL->pixels);
+
+    // Application des filtres
+    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+    // Déverrouillage
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // Fin de la méthode
+    SDL_FreeSurface(imageSDL);
+    return true;
+}
+
+GLuint Texture::getID() const
+{
+    return m_id;
+}
+
+SDL_Surface* Texture::inverserPixels(SDL_Surface *imageSource) const
+{
+    // Copie conforme de l'image source sans les pixels
+    SDL_Surface *imageInversee = SDL_CreateRGBSurface(0, imageSource->w, imageSource->h, imageSource->format->BitsPerPixel, imageSource->format->Rmask,
+                                                         imageSource->format->Gmask, imageSource->format->Bmask, imageSource->format->Amask);
+
+
+    // Tableau intermédiaires permettant de manipuler les pixels
+    unsigned char* pixelsSources = (unsigned char*) imageSource->pixels;
+    unsigned char* pixelsInverses = (unsigned char*) imageInversee->pixels;
+
+
+    // Inversion des pixels
+    for(int i = 0; i < imageSource->h; i++)
+    {
+        for(int j = 0; j < imageSource->w * imageSource->format->BytesPerPixel; j++)
+            pixelsInverses[(imageSource->w * imageSource->format->BytesPerPixel * (imageSource->h - 1 - i)) + j] = pixelsSources[(imageSource->w * imageSource->format->BytesPerPixel * i) + j];
+    }
+
+
+    // Retour de l'image inversée
+    return imageInversee;
+}
+

cubeWorld/Cubes/Texture.h

@@ -0,0 +1,37 @@
+#ifndef TEXTURE_H_INCLUDED
+#define TEXTURE_H_INCLUDED
+
+// Includes OpenGL + SDL
+#ifdef WIN32
+#include <GL/glew.h>
+#else
+#define GL3_PROTOTYPES 1
+#include <GL/gl.h>
+#endif
+
+#include <SDL2/SDL.h>
+
+// Basiques
+#include <iostream>
+
+// Classe Texture
+class Texture
+{
+    public:
+        Texture();
+        Texture(Texture const &textureACopier);
+        ~Texture();
+        Texture& operator=(Texture const &textureACopier);
+
+        bool charger(std::string fichierImage);
+        GLuint getID() const;
+        SDL_Surface* inverserPixels(SDL_Surface *imageSource) const;
+
+    private:
+        GLuint m_id;
+        std::string m_chemin;
+
+};
+
+
+#endif // TEXTURE_H_INCLUDED

cubeWorld/SceneOpenGL.cpp

@@ -0,0 +1,159 @@
+#include "SceneOpenGL.h"
+
+SceneOpenGL::SceneOpenGL(std::string titre, int largeur, int hauteur)
+: m_titreFenetre(titre), m_largeurFenetre(largeur), m_hauteurFenetre(hauteur), m_fenetre(0), m_contexteOpenGL(0),
+m_camera(glm::vec3(-30.0f,1.78f*2.0f,-22.2f),glm::vec3(0.0,2.6,0.0),glm::vec3(0.0,1.0,0.0),0.32,0.36)
+{
+
+}
+
+SceneOpenGL::~SceneOpenGL()
+{
+    SDL_GL_DeleteContext(m_contexteOpenGL);
+    SDL_DestroyWindow(m_fenetre);
+    SDL_Quit();
+}
+
+bool SceneOpenGL::initialiserFenetre()
+{
+    // Initialisation de la SDL
+    if(SDL_Init(SDL_INIT_VIDEO) < 0)
+    {
+        std::cout << "Erreur lors de l'initialisation de la SDL : " << SDL_GetError() << std::endl;
+        SDL_Quit();
+
+        return false;
+    }
+
+
+    // Version d'OpenGL
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+
+
+    // Double Buffer
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+
+
+    // Création de la fenêtre
+    m_fenetre = SDL_CreateWindow(m_titreFenetre.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+                                 m_largeurFenetre, m_hauteurFenetre, SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
+    if(m_fenetre == 0)
+    {
+        std::cout << "Erreur lors de la creation de la fenetre : " << SDL_GetError() << std::endl;
+        SDL_Quit();
+
+        return false;
+    }
+    m_input.setWindow(m_fenetre);
+
+
+    // Création du contexte OpenGL
+    m_contexteOpenGL = SDL_GL_CreateContext(m_fenetre);
+    if(m_contexteOpenGL == 0)
+    {
+        std::cout << SDL_GetError() << std::endl;
+        SDL_DestroyWindow(m_fenetre);
+        SDL_Quit();
+
+        return false;
+    }
+
+    return true;
+}
+
+bool SceneOpenGL::initGL()
+{
+    glEnable(GL_DEPTH_TEST);
+    return true;
+}
+
+void SceneOpenGL::bouclePrincipale()
+{
+    /// Variables
+    //Gestion du temps
+    unsigned int frameRate (1000 / 36);//36fps
+    Uint32 debutBoucle(0), finBoucle(0), tempsEcoule(0);
+    //Matrices
+    glm::mat4 projection;
+    glm::mat4 modelView(1.0);
+    glm::mat4 sauvegarde(1.0);//Pour sauvegarder modelView
+    //Vecteurs
+    glm::vec3 axeX(1.0,0.0,0.0);
+    glm::vec3 axeY(0.0,1.0,0.0);
+    glm::vec3 axeZ(0.0,0.0,1.0);
+    //Objets
+    Cube caisseBasique(2.0,"Shaders/couleur3D.vert", "Shaders/couleur3D.frag");
+    caisseBasique.charger();
+    float rotation(0.0);
+    float translation(1.0);
+    float acceleration(0.0);
+
+    ///Initialisation
+    projection = glm::perspective(70.0, (double) m_largeurFenetre / m_hauteurFenetre, 1.0, 100.0);
+    m_input.capturerPointeur(true);
+    m_input.afficherPointeur(false);
+    m_input.setMoveKeys(SDL_SCANCODE_W, SDL_SCANCODE_S, SDL_SCANCODE_D, SDL_SCANCODE_A);
+
+    /// Boucle principale
+    bool terminer(false);
+    while(!m_input.terminer() && !terminer)
+    {
+        // Amorce boucle
+        debutBoucle = SDL_GetTicks();
+
+        // Gestion des évènements
+        m_input.updateEvenements();
+        terminer = m_input.getTouche(SDL_SCANCODE_ESCAPE);
+        m_camera.setVol(m_input.getTouche(SDL_SCANCODE_LSHIFT));
+        if (m_input.getTouche(SDL_SCANCODE_P))
+            m_camera.setPosition(glm::vec3(30.0,1.78*2.0,22.2));
+        m_camera.deplacer(m_input);
+
+        // Nettoyage
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        m_camera.lookAt(modelView);
+
+        // Mouvements
+        rotation += 1.0;
+        if (rotation >= 360.0)
+            rotation -= 360.0;
+
+        acceleration = -translation*0.004+acceleration;
+        translation += acceleration;
+
+        //Save
+            sauvegarde = modelView;
+        ///Cube 1
+            //Transformations
+            modelView = glm::translate(sauvegarde, glm::vec3(-2.5,1.0,-0.3));
+            modelView = glm::rotate(modelView, 36.6f, axeY);
+            //Afficher
+            caisseBasique.afficher(projection,modelView);
+        ///Cube 2
+            //Transformations
+            modelView = glm::translate(sauvegarde, glm::vec3(-0.4,1.0,-3.2));
+            //Afficher
+            caisseBasique.afficher(projection,modelView);
+        ///Cube 3
+            //Transformations
+            modelView = glm::translate(sauvegarde, glm::vec3(2.5,1.0,0.0));
+            //Afficher
+            caisseBasique.afficher(projection,modelView);
+
+
+        /// Actualisation de la fenêtre
+        SDL_GL_SwapWindow(m_fenetre);
+
+        /// Temps
+        // Calcul du temps écoulé
+        finBoucle = SDL_GetTicks();
+        tempsEcoule = finBoucle - debutBoucle;
+        // Si nécessaire, on met en pause le programme
+        if(tempsEcoule < frameRate)
+            SDL_Delay(frameRate - tempsEcoule);
+    }
+}
+

cubeWorld/SceneOpenGL.h

@@ -0,0 +1,48 @@
+#ifndef SCENEOPENGL_H_INCLUDED
+#define SCENEOPENGL_H_INCLUDED
+
+// Includes GLM
+#include <glm/glm.hpp>
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// Includes OpenGL
+#include <SDL2/SDL.h>
+#define GL3_PROTOTYPES 1
+#include <GL/gl.h>
+
+//Includes de base
+#include <string>
+#include <iostream>
+
+//Autres includes
+#include "CamControl/InputAndJoy.h"
+#include "CamControl/Camera.h"
+#include "Cubes/Cube.h"
+
+class SceneOpenGL
+{
+    public:
+
+    SceneOpenGL(std::string titre, int largeur, int hauteur);
+    ~SceneOpenGL();
+
+    bool initialiserFenetre();
+    bool initGL();
+    void bouclePrincipale();
+
+
+    private:
+
+    std::string m_titreFenetre;
+    int m_largeurFenetre;
+    int m_hauteurFenetre;
+
+    SDL_Window* m_fenetre;
+    SDL_GLContext m_contexteOpenGL;
+    Camera m_camera;
+    InputAndJoy m_input;
+};
+
+#endif // SCENEOPENGL_H_INCLUDED

cubeWorld/Shader.cpp

@@ -0,0 +1,191 @@
+#include "Shader.h"
+
+// Constructeurs et Destructeur
+Shader::Shader() : m_vertexID(0), m_fragmentID(0), m_programID(0), m_vertexSource(), m_fragmentSource()
+{}
+
+Shader::Shader(Shader const &shaderACopier)
+{
+    // Copie des fichiers sources
+    m_vertexSource = shaderACopier.m_vertexSource;
+    m_fragmentSource = shaderACopier.m_fragmentSource;
+
+    // Chargement du nouveau shader
+    charger();
+}
+
+Shader::Shader(std::string vertexSource, std::string fragmentSource) : m_vertexID(0), m_fragmentID(0), m_programID(0),
+                                                                       m_vertexSource(vertexSource), m_fragmentSource(fragmentSource)
+{}
+
+Shader::~Shader()
+{
+    // Destruction du shader
+    glDeleteShader(m_vertexID);
+    glDeleteShader(m_fragmentID);
+    glDeleteProgram(m_programID);
+}
+
+// Méthodes
+Shader& Shader::operator=(Shader const &shaderACopier)
+{
+    // Copie des fichiers sources
+    m_vertexSource = shaderACopier.m_vertexSource;
+    m_fragmentSource = shaderACopier.m_fragmentSource;
+
+    // Chargement du nouveau shader
+    charger();
+
+    // Retour du pointeur this
+    return *this;
+}
+
+bool Shader::charger()
+{
+    // Destruction d'un éventuel ancien Shader
+    if(glIsShader(m_vertexID) == GL_TRUE)
+        glDeleteShader(m_vertexID);
+
+    if(glIsShader(m_fragmentID) == GL_TRUE)
+        glDeleteShader(m_fragmentID);
+
+    if(glIsProgram(m_programID) == GL_TRUE)
+        glDeleteProgram(m_programID);
+
+    // Compilation des shaders
+    if(!compilerShader(m_vertexID, GL_VERTEX_SHADER, m_vertexSource))
+        return false;
+
+    if(!compilerShader(m_fragmentID, GL_FRAGMENT_SHADER, m_fragmentSource))
+        return false;
+
+    // Création du programme
+    m_programID = glCreateProgram();
+
+    // Association des shaders
+    glAttachShader(m_programID, m_vertexID);
+    glAttachShader(m_programID, m_fragmentID);
+
+    // Verrouillage des entrées shader
+    glBindAttribLocation(m_programID, 0, "in_Vertex");
+    glBindAttribLocation(m_programID, 1, "in_Color");
+    glBindAttribLocation(m_programID, 2, "in_TexCoord0");
+
+    // Linkage du programme
+    glLinkProgram(m_programID);
+
+    // Vérification du linkage
+    GLint erreurLink(0);
+    glGetProgramiv(m_programID, GL_LINK_STATUS, &erreurLink);
+
+    // S'il y a eu une erreur
+    if(erreurLink != GL_TRUE)
+    {
+        // Récupération de la taille de l'erreur
+        GLint tailleErreur(0);
+        glGetProgramiv(m_programID, GL_INFO_LOG_LENGTH, &tailleErreur);
+
+        // Allocation de mémoire
+        char *erreur = new char[tailleErreur + 1];
+
+        // Récupération de l'erreur
+        glGetShaderInfoLog(m_programID, tailleErreur, &tailleErreur, erreur);
+        erreur[tailleErreur] = '\0';
+
+        // Affichage de l'erreur
+        std::cout << erreur << std::endl;
+
+        // Libération de la mémoire et retour du booléen false
+        delete[] erreur;
+        glDeleteProgram(m_programID);
+
+        return false;
+    }
+
+    // Sinon c'est que tout s'est bien passé
+    else
+        return true;
+}
+
+bool Shader::compilerShader(GLuint &shader, GLenum type, std::string const &fichierSource)
+{
+    // Création du shader
+    shader = glCreateShader(type);
+
+    // Vérification du shader
+    if(shader == 0)
+    {
+        std::cout << "Erreur, le type de shader (" << type << ") n'existe pas" << std::endl;
+        return false;
+    }
+
+    // Flux de lecture
+    std::ifstream fichier(fichierSource.c_str());
+
+    // Test d'ouverture
+    if(!fichier)
+    {
+        std::cout << "Erreur le fichier " << fichierSource << " est introuvable" << std::endl;
+        glDeleteShader(shader);
+
+        return false;
+    }
+
+    // Strings permettant de lire le code source
+    std::string ligne;
+    std::string codeSource;
+
+    // Lecture
+    while(getline(fichier, ligne))
+        codeSource += ligne + '\n';
+
+    // Fermeture du fichier
+    fichier.close();
+
+    // Récupération de la chaine C du code source
+    const GLchar* chaineCodeSource = codeSource.c_str();
+
+    // Envoi du code source au shader
+    glShaderSource(shader, 1, &chaineCodeSource, 0);
+
+    // Compilation du shader
+    glCompileShader(shader);
+
+    // Vérification de la compilation
+    GLint erreurCompilation(0);
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &erreurCompilation);
+
+    // S'il y a eu une erreur
+    if(erreurCompilation != GL_TRUE)
+    {
+        // Récupération de la taille de l'erreur
+        GLint tailleErreur(0);
+        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &tailleErreur);
+
+        // Allocation de mémoire
+        char *erreur = new char[tailleErreur + 1];
+
+        // Récupération de l'erreur
+        glGetShaderInfoLog(shader, tailleErreur, &tailleErreur, erreur);
+        erreur[tailleErreur] = '\0';
+
+        // Affichage de l'erreur
+        std::cout << erreur << std::endl;
+
+        // Libération de la mémoire et retour du booléen false
+        delete[] erreur;
+        glDeleteShader(shader);
+
+        return false;
+    }
+
+    // Sinon c'est que tout s'est bien passé
+    else
+        return true;
+}
+
+// Getter
+GLuint Shader::getProgramID() const
+{
+    return m_programID;
+}

cubeWorld/Shader.h

@@ -0,0 +1,51 @@
+#ifndef DEF_SHADER
+#define DEF_SHADER
+
+// Include Windows
+#ifdef WIN32
+#include <GL/glew.h>
+
+// Include Mac
+#elif __APPLE__
+#define GL3_PROTOTYPES 1
+#include <OpenGL/gl3.h>
+
+// Include UNIX/Linux
+#else
+#define GL3_PROTOTYPES 1
+#include <GL/gl.h>
+#endif
+
+// Includes communs
+#include <iostream>
+#include <string>
+#include <fstream>
+
+// Classe Shader
+class Shader
+{
+    public:
+
+    Shader();
+    Shader(Shader const &shaderACopier);
+    Shader(std::string vertexSource, std::string fragmentSource);
+    ~Shader();
+
+    Shader& operator=(Shader const &shaderACopier);
+
+    bool charger();
+    bool compilerShader(GLuint &shader, GLenum type, std::string const &fichierSource);
+    GLuint getProgramID() const;
+
+
+    private:
+
+    GLuint m_vertexID;
+    GLuint m_fragmentID;
+    GLuint m_programID;
+
+    std::string m_vertexSource;
+    std::string m_fragmentSource;
+};
+
+#endif

cubeWorld/Shaders/basique2D.frag

@@ -0,0 +1,18 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Sortie Shader
+
+out vec4 out_Color;
+
+
+// Fonction main
+
+void main()
+{
+    // Couleur finale du pixel
+
+    out_Color = vec4(1.0, 1.0, 1.0, 1.0);
+}

cubeWorld/Shaders/basique2D.vert

@@ -0,0 +1,18 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrée Shader
+
+in vec2 in_Vertex;
+
+
+// Fonction main
+
+void main()
+{
+    // Position finale du vertex
+
+    gl_Position = vec4(in_Vertex, 0.0, 1.0);
+}

cubeWorld/Shaders/couleur2D.frag

@@ -0,0 +1,23 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrée
+
+in vec3 color;
+
+
+// Sortie 
+
+out vec4 out_Color;
+
+
+// Fonction main
+
+void main()
+{
+    // Couleur finale du pixel
+
+    out_Color = vec4(color, 1.0);
+}

cubeWorld/Shaders/couleur2D.vert

@@ -0,0 +1,29 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrées
+
+in vec2 in_Vertex;
+in vec3 in_Color;
+
+
+// Sortie
+
+out vec3 color;
+
+
+// Fonction main
+
+void main()
+{
+    // Position finale du vertex
+
+    gl_Position = vec4(in_Vertex, 0.0, 1.0);
+
+
+    // Envoi de la couleur au Fragment Shader
+
+    color = in_Color;
+}

cubeWorld/Shaders/couleur3D.frag

@@ -0,0 +1,23 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrée
+
+in vec3 color;
+
+
+// Sortie 
+
+out vec4 out_Color;
+
+
+// Fonction main
+
+void main()
+{
+    // Couleur finale du pixel
+
+    out_Color = vec4(color, 1.0);
+}

cubeWorld/Shaders/couleur3D.vert

@@ -0,0 +1,35 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrées
+
+in vec3 in_Vertex;
+in vec3 in_Color;
+
+
+// Uniform
+
+uniform mat4 projection;
+uniform mat4 modelview;
+
+
+// Sortie
+
+out vec3 color;
+
+
+// Fonction main
+
+void main()
+{
+    // Position finale du vertex en 3D
+
+    gl_Position = projection * modelview * vec4(in_Vertex, 1.0);
+
+
+    // Envoi de la couleur au Fragment Shader
+
+    color = in_Color;
+}

cubeWorld/Shaders/texture.frag

@@ -0,0 +1,28 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrée
+
+in vec2 coordTexture;
+
+
+// Uniform
+
+uniform sampler2D texture;
+
+
+// Sortie 
+
+out vec4 out_Color;
+
+
+// Fonction main
+
+void main()
+{
+    // Couleur du pixel
+
+    out_Color = texture2D(texture, coordTexture);
+}

cubeWorld/Shaders/texture.vert

@@ -0,0 +1,35 @@
+// Version du GLSL
+
+#version 150 core
+
+
+// Entrées
+
+in vec3 in_Vertex;
+in vec2 in_TexCoord0;
+
+
+// Uniform
+
+uniform mat4 projection;
+uniform mat4 modelview;
+
+
+// Sortie
+
+out vec2 coordTexture;
+
+
+// Fonction main
+
+void main()
+{
+    // Position finale du vertex en 3D
+
+    gl_Position = projection * modelview * vec4(in_Vertex, 1.0);
+
+
+    // Envoi des coordonnées de texture au Fragment Shader
+
+    coordTexture = in_TexCoord0;
+}

cubeWorld/main.cpp

@@ -0,0 +1,13 @@
+#include <iostream>
+#include "SceneOpenGL.h"
+
+int main(int argc, char **argv)
+{
+    SceneOpenGL plateau("Une relique trouvée _ OpenGL 3.3",1600,900);
+    if (!plateau.initialiserFenetre() || !plateau.initGL())
+        return -1;
+
+    plateau.bouclePrincipale();
+
+    return 0;
+}

cubeWorld/makefile

@@ -0,0 +1,25 @@
+CXX=g++
+CXXFLAGS=
+LDFLAGS=-lSDL2
+INC=
+LIB=
+
+EXEC=GlApp
+SRC=$(shell find . -name '*.cpp')
+OBJ=$(SRC:.cpp=.o)
+
+$(EXEC): $(OBJ)
+	@mkdir -p bin
+	$(CXX) -o bin/$@ $^ $(LDFLAGS) $(LIB)
+
+%.o : %.cpp
+	$(CXX) -o $@ -c $< $(CXXFLAGS) $(INC)
+
+clean:
+	rm -rf $(OBJ)
+
+distclean: clean
+	rm -rf ./bin
+
+exec: $(EXEC)
+	./bin/$(EXEC)