Import caban scene

caban/Cabane.cpp

@@ -0,0 +1,151 @@
+#include "Cabane.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+
+using namespace glm;
+
+
+// Constructeur et Destructeur
+
+Cabane::Cabane(std::string const vertexShader, std::string const fragmentShader) : m_shader(vertexShader, fragmentShader),
+                                                                                   m_textureMur("Textures/Mur.jpg"), m_textureToit("Textures/Toit.jpg")
+{
+    // Chargement du shader
+
+    m_shader.charger();
+
+
+    // Chargement des textures
+
+    m_textureMur.charger();
+    m_textureToit.charger();
+
+
+    // Vertices temporaires
+
+    float verticesTmp[] = {-5, 0, -5,   5, 0, -5,   5, 5, -5,      // Mur du Fond
+                           -5, 0, -5,   -5, 5, -5,   5, 5, -5,     // Mur du Fond
+
+                           -5, 0, -5,   -5, 0, 5,   -5, 5, 5,      // Mur Gauche
+                           -5, 0, -5,   -5, 5, -5,   -5, 5, 5,     // Mur Gauche
+
+                           5, 0, -5,   5, 0, 5,   5, 5, 5,         // Mur Droit
+                           5, 0, -5,   5, 5, -5,   5, 5, 5,        // Mur Droit
+
+                           -5, 5, -5,   5, 5, -5,   0, 6, -5,      // Combles
+
+                           -6, 4.8, -6,   -6, 4.8, 6,   0, 6, 6,   // Toit Gauche
+                           -6, 4.8, -6,   0, 6, -6,   0, 6, 6,     // Toit Gauche
+
+                           6, 4.8, -6,   6, 4.8, 6,   0, 6, 6,     // Toit Droit
+                           6, 4.8, -6,   0, 6, -6,   0, 6, 6};     // Toit Droit
+
+
+    // Coordonnées de texture temporaires
+
+    float coordTexture[] = {0, 0,   1, 0,   1, 1,        // Mur du Fond
+                            0, 0,   0, 1,   1, 1,        // Mur du Fond
+
+                            0, 0,   1, 0,   1, 1,        // Mur Gauche
+                            0, 0,   0, 1,   1, 1,        // Mur Gauche
+
+                            0, 0,   1, 0,   1, 1,        // Mur Droit
+                            0, 0,   0, 1,   1, 1,        // Mur Droit
+
+                            0, 0,   1, 0,   0.5, 0.5,    // Combles
+
+                            0, 0,   1, 0,   1, 1,        // Toit Gauche
+                            0, 0,   0, 1,   1, 1,        // Toit Gauche
+
+                            0, 0,   1, 0,   1, 1,        // Toit Droit
+                            0, 0,   0, 1,   1, 1};       // Toit Droit
+
+
+
+    // Copie des vertices
+
+    for(int i(0); i < 99; i++)
+        m_vertices[i] = verticesTmp[i];
+
+
+    // Copie des coordonnées
+
+    for(int i(0); i < 66; i++)
+        m_coordTexture[i] = coordTexture[i];
+}
+
+
+Cabane::~Cabane()
+{
+
+}
+
+
+// Méthodes
+
+void Cabane::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+
+    glUseProgram(m_shader.getProgramID());
+
+
+        // Envoi des vertices
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, m_vertices);
+        glEnableVertexAttribArray(0);
+
+
+        // Envoi des coordonnées de texture
+
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, m_coordTexture);
+        glEnableVertexAttribArray(2);
+
+
+        // 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 du Mur
+
+        glBindTexture(GL_TEXTURE_2D, m_textureMur.getID());
+
+
+        // Rendu
+
+        glDrawArrays(GL_TRIANGLES, 0, 21);
+
+
+        // Déverrouillage de la texture
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+
+        // Verrouillage de la texture du Toit
+
+        glBindTexture(GL_TEXTURE_2D, m_textureToit.getID());
+
+
+        // Rendu
+
+        glDrawArrays(GL_TRIANGLES, 21, 12);
+
+
+        // Déverrouillage de la texture
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+
+        // Désactivation des tableaux
+
+        glDisableVertexAttribArray(2);
+        glDisableVertexAttribArray(0);
+
+
+    // Désactivation du shader
+
+    glUseProgram(0);
+}

caban/Cabane.h

@@ -0,0 +1,52 @@
+#ifndef DEF_CABANE
+#define DEF_CABANE
+
+
+// Includes OpenGL
+
+#ifdef WIN32
+#include <glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+#endif
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <gtc/type_ptr.hpp>
+
+
+// Autres includes
+
+#include "Shader.h"
+#include "Texture.h"
+
+
+// Classe Cabane
+
+class Cabane
+{
+    public:
+
+    Cabane(std::string const vertexShader, std::string const fragmentShader);
+    ~Cabane();
+
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    private:
+
+    Shader m_shader;
+    Texture m_textureMur;
+    Texture m_textureToit;
+
+    float m_vertices[99];
+    float m_coordTexture[66];
+};
+
+#endif

caban/Caisse.cpp

@@ -0,0 +1,104 @@
+#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(texture)
+{
+    // Chargement de la texture
+
+    m_texture.charger();
+
+
+    // 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::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+
+    glUseProgram(m_shader.getProgramID());
+
+
+        // Envoi des vertices
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, m_vertices);
+        glEnableVertexAttribArray(0);
+
+
+        // Envoi des coordonnées de texture
+
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, m_coordTexture);
+        glEnableVertexAttribArray(2);
+
+
+        // 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ésactivation des tableaux
+
+        glDisableVertexAttribArray(2);
+        glDisableVertexAttribArray(0);
+
+
+    // Désactivation du shader
+
+    glUseProgram(0);
+}

caban/Caisse.h

@@ -0,0 +1,30 @@
+#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 afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    private:
+
+    Texture m_texture;
+    float m_coordTexture[72];
+};
+
+#endif

caban/Camera.cpp

@@ -0,0 +1,253 @@
+#include "Camera.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+
+using namespace glm;
+
+
+// Constructeurs et Destructeur
+
+Camera::Camera() : m_phi(0.0), m_theta(0.0), m_orientation(), m_axeVertical(0, 0, 1), m_deplacementLateral(), m_position(), m_pointCible(), m_sensibilite(0.0), m_vitesse(0.0)
+{
+
+}
+
+
+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_position(position), m_pointCible(pointCible),
+                                                                                                                    m_sensibilite(sensibilite), m_vitesse(vitesse)
+{
+    // Actualisation du point ciblé
+
+    setPointcible(pointCible);
+}
+
+
+Camera::~Camera()
+{
+
+}
+
+
+// Méthodes
+
+void Camera::orienter(int xRel, int 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 = cross(m_axeVertical, m_orientation);
+    m_deplacementLateral = normalize(m_deplacementLateral);
+
+
+    // Calcul du point ciblé pour OpenGL
+
+    m_pointCible = m_position + m_orientation;
+}
+
+
+void Camera::deplacer(Input const &input)
+{
+    // Gestion de l'orientation
+
+    if(input.mouvementSouris())
+        orienter(input.getXRel(), input.getYRel());
+
+
+    // Avancée de la caméra
+
+    if(input.getTouche(SDL_SCANCODE_UP))
+    {
+        m_position = m_position + m_orientation * m_vitesse;
+        m_pointCible = m_position + m_orientation;
+    }
+
+
+    // Recul de la caméra
+
+    if(input.getTouche(SDL_SCANCODE_DOWN))
+    {
+        m_position = m_position - m_orientation * m_vitesse;
+        m_pointCible = m_position + m_orientation;
+    }
+
+
+    // Déplacement vers la gauche
+
+    if(input.getTouche(SDL_SCANCODE_LEFT))
+    {
+        m_position = m_position + m_deplacementLateral * m_vitesse;
+        m_pointCible = m_position + m_orientation;
+    }
+
+
+    // Déplacement vers la droite
+
+    if(input.getTouche(SDL_SCANCODE_RIGHT))
+    {
+        m_position = m_position - m_deplacementLateral * m_vitesse;
+        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_vitesse;
+}
+
+
+float Camera::getVitesse() const
+{
+    return m_vitesse;
+}
+
+
+void Camera::setSensibilite(float sensibilite)
+{
+    m_sensibilite = sensibilite;
+}
+
+
+void Camera::setVitesse(float vitesse)
+{
+    m_vitesse = vitesse;
+}

caban/Camera.h

@@ -0,0 +1,57 @@
+#ifndef DEF_CAMERA
+#define DEF_CAMERA
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <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(int xRel, int 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);
+
+
+    private:
+
+    float m_phi;
+    float m_theta;
+    glm::vec3 m_orientation;
+
+    glm::vec3 m_axeVertical;
+    glm::vec3 m_deplacementLateral;
+
+    glm::vec3 m_position;
+    glm::vec3 m_pointCible;
+
+    float m_sensibilite;
+    float m_vitesse;
+};
+
+#endif

caban/Cristal.cpp

@@ -0,0 +1,112 @@
+#include "Cristal.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+
+using namespace glm;
+
+
+// Constructeur et Destructeur
+
+Cristal::Cristal(std::string const vertexShader, std::string const fragmentShader, std::string const texture) : m_shader(vertexShader, fragmentShader), m_texture(texture)
+{
+    // Chargement du shader
+
+    m_shader.charger();
+
+
+    // Chargement de la texture
+
+    m_texture.charger();
+
+
+    // Vertices temporaires
+
+    float verticesTmp[] = {-0.5, 0, -0.5,   0.5, 0, -0.5,   0, 1, 0,      // Triangle 1
+                           0.5, 0, -0.5,   0.5, 0, 0.5,  0, 1, 0,         // Triangle 2
+                           0.5, 0, 0.5,   -0.5, 0, 0.5,   0, 1, 0,        // Triangle 3
+                           -0.5, 0, 0.5,   -0.5, 0, -0.5,   0, 1, 0,      // Triangle 4
+
+                           -0.5, 0, -0.5,   0.5, 0, -0.5,   0, -1, 0,     // Triangle 5
+                           0.5, 0, -0.5,   0.5, 0, 0.5,  0, -1, 0,        // Triangle 6
+                           0.5, 0, 0.5,   -0.5, 0, 0.5,   0, -1, 0,       // Triangle 7
+                           -0.5, 0, 0.5,   -0.5, 0, -0.5,   0, -1, 0};    // Triangle 8
+
+
+    // Coordonnées de texture temporaires
+
+    float coordTexture[] = {0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 1
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 2
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 3
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 4
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 5
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 6
+                            0, 0,   0.5, 0,   0.5, 0.5,      // Triangle 7
+                            0, 0,   0.5, 0,   0.5, 0.5};     // Triangle 8
+
+
+    // Copie des vertices
+
+    for(int i(0); i < 72; i++)
+        m_vertices[i] = verticesTmp[i];
+
+
+    // Copie des coordonnées
+
+    for(int i(0); i < 48; i++)
+        m_coordTexture[i] = coordTexture[i];
+}
+
+
+// Méthodes
+
+void Cristal::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+
+    glUseProgram(m_shader.getProgramID());
+
+
+        // Envoi des vertices
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, m_vertices);
+        glEnableVertexAttribArray(0);
+
+
+        // Envoi des coordonnées de texture
+
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, m_coordTexture);
+        glEnableVertexAttribArray(2);
+
+
+        // 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, 24);
+
+
+        // Déverrouillage de la texture
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+
+        // Désactivation des tableaux
+
+        glDisableVertexAttribArray(2);
+        glDisableVertexAttribArray(0);
+
+
+    // Désactivation du shader
+
+    glUseProgram(0);
+}

caban/Cristal.h

@@ -0,0 +1,51 @@
+#ifndef DEF_CRISTAL
+#define DEF_CRISTAL
+
+
+// Includes OpenGL
+
+#ifdef WIN32
+#include <glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+#endif
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <gtc/type_ptr.hpp>
+
+
+// Autres includes
+
+#include "Shader.h"
+#include "Texture.h"
+
+
+// Classe Cristal
+
+class Cristal
+{
+    public:
+
+    Cristal(std::string const vertexShader, std::string const fragmentShader, std::string const texture);
+    Cristal();
+
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    private:
+
+    Shader m_shader;
+    Texture m_texture;
+
+    float m_vertices[72];
+    float m_coordTexture[48];
+};
+
+#endif

caban/Cube.cpp

@@ -0,0 +1,123 @@
+#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)
+{
+    // 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()
+{
+
+}
+
+
+// Méthodes
+
+void Cube::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+
+    glUseProgram(m_shader.getProgramID());
+
+
+        // Envoi des vertices
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, m_vertices);
+        glEnableVertexAttribArray(0);
+
+
+        // Envoi de la couleur
+
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, m_couleurs);
+        glEnableVertexAttribArray(1);
+
+
+        // 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ésactivation des tableaux
+
+        glDisableVertexAttribArray(1);
+        glDisableVertexAttribArray(0);
+
+
+    // Désactivation du shader
+
+    glUseProgram(0);
+}
+

caban/Cube.h

@@ -0,0 +1,48 @@
+#ifndef DEF_CUBE
+#define DEF_CUBE
+
+
+// Includes OpenGL
+
+#ifdef WIN32
+#include <glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+#endif
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <gtc/type_ptr.hpp>
+
+
+// Includes
+
+#include "Shader.h"
+
+
+// Classe Cube
+
+class Cube
+{
+    public:
+
+    Cube(float taille, std::string const vertexShader, std::string const fragmentShader);
+    ~Cube();
+
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    protected:
+
+    Shader m_shader;
+    float m_vertices[108];
+    float m_couleurs[108];
+};
+
+#endif

caban/Input.cpp

@@ -0,0 +1,178 @@
+#include "Input.h"
+
+
+// Constructeur et Destructeur
+
+Input::Input() : m_x(0), m_y(0), m_xRel(0), m_yRel(0), m_terminer(false)
+{
+    // 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:
+
+                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;
+        }
+    }
+}
+
+
+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) const
+{
+    if(reponse)
+        SDL_SetRelativeMouseMode(SDL_TRUE);
+
+    else
+        SDL_SetRelativeMouseMode(SDL_FALSE);
+}
+
+
+
+// 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;
+}

caban/Input.h

@@ -0,0 +1,49 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+// Include
+
+#include <SDL.h>
+
+
+// Classe
+
+class Input
+{
+    public:
+
+    Input();
+    ~Input();
+
+    void updateEvenements();
+    bool terminer() const;
+    void afficherPointeur(bool reponse) const;
+    void capturerPointeur(bool reponse) const;
+
+    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;
+
+
+    private:
+
+    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;
+
+    bool m_terminer;
+};
+
+#endif
+

caban/SceneOpenGL.cpp

@@ -0,0 +1,284 @@
+#include "SceneOpenGL.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+
+using namespace glm;
+
+
+// Constructeur de Destucteur
+
+SceneOpenGL::SceneOpenGL(std::string titreFenetre, int largeurFenetre, int hauteurFenetre) : m_titreFenetre(titreFenetre), m_largeurFenetre(largeurFenetre),
+                                                                                             m_hauteurFenetre(hauteurFenetre), m_fenetre(0), m_contexteOpenGL(0), m_input()
+{
+
+}
+
+
+SceneOpenGL::~SceneOpenGL()
+{
+    SDL_GL_DeleteContext(m_contexteOpenGL);
+    SDL_DestroyWindow(m_fenetre);
+    SDL_Quit();
+}
+
+
+// Méthodes
+
+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, 1);
+
+
+    // 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_OPENGL);
+
+    if(m_fenetre == 0)
+    {
+        std::cout << "Erreur lors de la creation de la fenetre : " << SDL_GetError() << std::endl;
+        SDL_Quit();
+
+        return false;
+    }
+
+
+    // 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()
+{
+    #ifdef WIN32
+
+        // On initialise GLEW
+
+        GLenum initialisationGLEW( glewInit() );
+
+
+        // Si l'initialisation a échoué :
+
+        if(initialisationGLEW != GLEW_OK)
+        {
+            // On affiche l'erreur grâce à la fonction : glewGetErrorString(GLenum code)
+
+            std::cout << "Erreur d'initialisation de GLEW : " << glewGetErrorString(initialisationGLEW) << std::endl;
+
+
+            // On quitte la SDL
+
+            SDL_GL_DeleteContext(m_contexteOpenGL);
+            SDL_DestroyWindow(m_fenetre);
+            SDL_Quit();
+
+            return false;
+        }
+
+    #endif
+
+
+    // Activation du Depth Buffer
+
+    glEnable(GL_DEPTH_TEST);
+
+
+    // Tout s'est bien passé, on retourne true
+
+    return true;
+}
+
+
+void SceneOpenGL::bouclePrincipale()
+{
+    // Variables
+
+    unsigned int frameRate (1000 / 50);
+    Uint32 debutBoucle(0), finBoucle(0), tempsEcoule(0);
+
+
+    // Matrices
+
+    mat4 projection;
+    mat4 modelview;
+
+    projection = perspective(70.0, (double) m_largeurFenetre / m_hauteurFenetre, 1.0, 100.0);
+    modelview = mat4(1.0);
+
+
+    // Caméra mobile
+
+    Camera camera(vec3(3, 4, 10), vec3(0, 2.1, 2), vec3(0, 1, 0), 0.5, 0.5);
+    m_input.afficherPointeur(false);
+    m_input.capturerPointeur(true);
+
+
+    // Cabanne
+
+    Cabane cabane("Shaders/texture.vert", "Shaders/texture.frag");
+
+
+    // Sols
+
+    Sol solHerbeux(30.0, 30.0, 15, 15, "Shaders/texture.vert", "Shaders/texture.frag", "Textures/Ex.bmp");
+    Sol solTerreux(10.0, 10.0, 5, 5, "Shaders/texture.vert", "Shaders/texture.frag", "Textures/Ex.bmp");
+
+
+    // Caisses
+
+    Caisse caisse(2.0, "Shaders/texture.vert", "Shaders/texture.frag", "Textures/Ex.bmp");
+    Caisse caisseDanger(2.0, "Shaders/texture.vert", "Shaders/texture.frag", "Textures/Ex.bmp");
+
+
+    // Cristal
+
+    Cristal cristal("Shaders/texture.vert", "Shaders/texture.frag", "Textures/Ex.bmp");
+    float angle(0.0);
+
+
+    // Boucle principale
+
+    while(!m_input.terminer())
+    {
+        // On définit le temps de début de boucle
+
+        debutBoucle = SDL_GetTicks();
+
+
+        // Gestion des évènements
+
+        m_input.updateEvenements();
+
+        if(m_input.getTouche(SDL_SCANCODE_ESCAPE))
+            break;
+
+        camera.deplacer(m_input);
+
+
+        // Nettoyage de l'écran
+
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+
+        // Gestion de la caméra
+
+        camera.lookAt(modelview);
+
+
+
+        /* ***** Rendu ***** */
+
+
+        // Affichage de la cabane
+
+        cabane.afficher(projection, modelview);
+
+
+        // Affichage du sol terreux
+
+        solTerreux.afficher(projection, modelview);
+
+
+        // Affichage du sol herbeux
+
+        mat4 sauvegardeModelview = modelview;
+
+            modelview = translate(modelview, vec3(0, -0.01, 0));
+            solHerbeux.afficher(projection, modelview);
+
+        modelview = sauvegardeModelview;
+
+
+        // Sauvegarde de la matrice
+
+        sauvegardeModelview = modelview;
+
+
+            // Première caisse
+
+            modelview = translate(modelview, vec3(-2.5, 1, -3));
+            caisse.afficher(projection, modelview);
+
+
+            // Deuxième caisse
+
+            modelview = translate(modelview, vec3(5, 0, 1));
+            caisseDanger.afficher(projection, modelview);
+
+
+            // Troisième caisse
+
+            modelview = translate(modelview, vec3(-2.5, 0, 4));
+            caisse.afficher(projection, modelview);
+
+
+            // Rotation du cristal
+
+            angle++;
+
+            if(angle > 360)
+                angle -= 360;
+
+
+            // Affichage du cristal
+
+            modelview = translate(modelview, vec3(0, 2.1, 0));
+            modelview = rotate(modelview, angle, vec3(0, 1, 0));
+
+            cristal.afficher(projection, modelview);
+
+
+        // Restauration de la matrice
+
+        modelview = sauvegardeModelview;
+
+
+        // Actualisation de la fenêtre
+
+        SDL_GL_SwapWindow(m_fenetre);
+
+
+        // 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);
+    }
+}

caban/SceneOpenGL.h

@@ -0,0 +1,67 @@
+#ifndef DEF_SCENEOPENGL
+#define DEF_SCENEOPENGL
+
+
+// Includes
+
+#ifdef WIN32
+#include <glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+#endif
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <gtc/type_ptr.hpp>
+
+
+// Autres includes
+
+#include <SDL.h>
+#include <iostream>
+#include <string>
+#include "Shader.h"
+#include "Cube.h"
+#include "Input.h"
+#include "Texture.h"
+#include "Caisse.h"
+#include "Camera.h"
+#include "Cabane.h"
+#include "Sol.h"
+#include "Cristal.h"
+
+
+// Classe
+
+class SceneOpenGL
+{
+    public:
+
+    SceneOpenGL(std::string titreFenetre, int largeurFenetre, int hauteurFenetre);
+    ~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;
+    SDL_Event m_evenements;
+    Input m_input;
+};
+
+#endif
+

caban/Shader.cpp

@@ -0,0 +1,273 @@
+#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;
+}

caban/Shader.h

@@ -0,0 +1,62 @@
+#ifndef DEF_SHADER
+#define DEF_SHADER
+
+
+// Include Windows
+
+#ifdef WIN32
+#include <glew.h>
+
+
+// Include Mac
+
+#elif __APPLE__
+#define GL3_PROTOTYPES 1
+#include <OpenGL/gl3.h>
+
+
+// Include UNIX/Linux
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.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

caban/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);
+}

caban/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);
+}

caban/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);
+}

caban/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;
+}

caban/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);
+}

caban/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;
+}

caban/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 = texture(texture, coordTexture);
+}

caban/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;
+}

caban/Sol.cpp

@@ -0,0 +1,111 @@
+#include "Sol.h"
+
+
+// Permet d'éviter la ré-écriture du namespace glm::
+
+using namespace glm;
+
+
+// Constructeur de Destructeur
+
+Sol::Sol(float longueur, float largeur, int repetitionLongueur, int repetitionLargeur, std::string const vertexShader, std::string const fragmentShader, std::string const texture) :
+         m_shader(vertexShader, fragmentShader), m_texture(texture)
+{
+    // Chargement du shader
+
+    m_shader.charger();
+
+
+    // Chargement de la texture
+
+    m_texture.charger();
+
+
+    // Division de la taille
+
+    longueur /= 2.0;
+    largeur /= 2.0;
+
+
+    // Vertices temporaires
+
+    float verticesTmp[] = {-longueur, 0, -largeur,   longueur, 0, -largeur,   longueur, 0, largeur,     // Triangle 1
+                           -longueur, 0, -largeur,   -longueur, 0, largeur,   longueur, 0, largeur};    // Triangle 2
+
+
+    // Coordonnées de texture temporaires
+
+    float coordTexture[] = {0, 0,   repetitionLongueur, 0,   repetitionLongueur, repetitionLargeur,      // Triangle 1
+                            0, 0,   0, repetitionLargeur,   repetitionLongueur, repetitionLargeur};      // Triangle 2
+
+
+    // Copie des vertices
+
+    for(int i(0); i < 18; i++)
+        m_vertices[i] = verticesTmp[i];
+
+
+    // Copie des coordonnées
+
+    for(int i(0); i < 12; i++)
+        m_coordTexture[i] = coordTexture[i];
+}
+
+Sol::~Sol()
+{
+
+}
+
+
+// Méthodes
+
+void Sol::afficher(glm::mat4 &projection, glm::mat4 &modelview)
+{
+    // Activation du shader
+
+    glUseProgram(m_shader.getProgramID());
+
+
+        // Envoi des vertices
+
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, m_vertices);
+        glEnableVertexAttribArray(0);
+
+
+        // Envoi des coordonnées de texture
+
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, m_coordTexture);
+        glEnableVertexAttribArray(2);
+
+
+        // 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, 6);
+
+
+        // Déverrouillage de la texture
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+
+        // Désactivation des tableaux
+
+        glDisableVertexAttribArray(2);
+        glDisableVertexAttribArray(0);
+
+
+    // Désactivation du shader
+
+    glUseProgram(0);
+}

caban/Sol.h

@@ -0,0 +1,51 @@
+#ifndef DEF_SOL
+#define DEF_SOL
+
+
+// Includes OpenGL
+
+#ifdef WIN32
+#include <glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+#endif
+
+
+// Includes GLM
+
+#include <glm.hpp>
+#include <gtx/transform.hpp>
+#include <gtc/type_ptr.hpp>
+
+
+// Autres includes
+
+#include "Shader.h"
+#include "Texture.h"
+
+
+// Classe Sol
+
+class Sol
+{
+    public:
+
+    Sol(float longueur, float largeur, int repetitionLongueur, int repetitionLargeur, std::string const vertexShader, std::string const fragmentShader, std::string const texture);
+    ~Sol();
+
+    void afficher(glm::mat4 &projection, glm::mat4 &modelview);
+
+
+    private:
+
+    Shader m_shader;
+    Texture m_texture;
+
+    float m_vertices[18];
+    float m_coordTexture[12];
+};
+
+#endif

caban/Texture.cpp

@@ -0,0 +1,205 @@
+#include "Texture.h"
+
+
+// Constructeurs et Destructeur
+
+Texture::Texture() : m_id(0), m_fichierImage("")
+{
+
+}
+
+
+Texture::Texture(Texture const &textureACopier)
+{
+    // Copie de la texture
+
+    m_fichierImage = textureACopier.m_fichierImage;
+    charger();
+}
+
+
+Texture::Texture(std::string fichierImage) : m_id(0), m_fichierImage(fichierImage)
+{
+
+}
+
+
+Texture::~Texture()
+{
+    // Destruction de la texture
+
+    glDeleteTextures(1, &m_id);
+}
+
+
+// Méthodes
+
+Texture& Texture::operator=(Texture const &textureACopier)
+{
+    // Copie de la texture
+
+    m_fichierImage = textureACopier.m_fichierImage;
+    charger();
+
+
+    // Retour du pointeur *this
+
+    return *this;
+}
+
+
+bool Texture::charger()
+{
+    // Chargement de l'image dans une surface SDL
+
+    SDL_Surface *imageSDL = SDL_LoadBMP(m_fichierImage.c_str());
+
+    if(imageSDL == 0)
+    {
+        std::cout << "Erreur : " << SDL_GetError() << std::endl;
+        return false;
+    }
+
+
+    // Inversion de l'image
+
+    SDL_Surface *imageInversee = inverserPixels(imageSDL);
+    SDL_FreeSurface(imageSDL);
+
+
+    // 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
+
+    if(imageInversee->format->BytesPerPixel == 3)
+    {
+        // Format interne
+
+        formatInterne = GL_RGB;
+
+
+        // Format
+
+        if(imageInversee->format->Rmask == 0xff)
+            format = GL_RGB;
+
+        else
+            format = GL_BGR;
+    }
+
+
+    // Détermination du format et du format interne pour les images à 4 composantes
+
+    else if(imageInversee->format->BytesPerPixel == 4)
+    {
+        // Format interne
+
+        formatInterne = GL_RGBA;
+
+
+        // Format
+
+        if(imageInversee->format->Rmask == 0xff)
+            format = GL_RGBA;
+
+        else
+            format = 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(imageInversee);
+
+        return false;
+    }
+
+
+    // Copie des pixels
+
+    glTexImage2D(GL_TEXTURE_2D, 0, formatInterne, imageInversee->w, imageInversee->h, 0, format, GL_UNSIGNED_BYTE, imageInversee->pixels);
+
+
+    // Application des filtres
+
+    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(imageInversee);
+    return true;
+}
+
+
+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;
+}
+
+
+
+
+GLuint Texture::getID() const
+{
+    return m_id;
+}
+
+
+void Texture::setFichierImage(const std::string &fichierImage)
+{
+    m_fichierImage = fichierImage;
+}
+

caban/Texture.h

@@ -0,0 +1,52 @@
+#ifndef DEF_TEXTURE
+#define DEF_TEXTURE
+
+
+// Include
+
+#ifdef WIN32
+#include <glew.h>
+
+#elif __APPLE__
+#define GL3_PROTOTYPES 1
+#include <OpenGL/gl3.h>
+#include <SDL2_image/SDL_image.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+#include <SDL2/SDL_image.h>
+
+#endif
+
+#include <SDL.h>
+#include <iostream>
+#include <string>
+
+
+// Classe Textures
+
+class Texture
+{
+    public:
+
+    Texture();
+    Texture(Texture const &textureACopier);
+    Texture(std::string fichierImage);
+    ~Texture();
+
+    Texture& operator=(Texture const &textureACopier);
+    bool charger();
+    SDL_Surface* inverserPixels(SDL_Surface *imageSource) const;
+
+    GLuint getID() const;
+    void setFichierImage(const std::string &fichierImage);
+
+
+    private:
+
+    GLuint m_id;
+    std::string m_fichierImage;
+};
+
+#endif

caban/main.cpp

@@ -0,0 +1,28 @@
+#include "SceneOpenGL.h"
+
+
+int main(int argc, char **argv)
+{
+    // Création de la sène
+
+    SceneOpenGL scene("OpenGL", 800, 600);
+
+
+    // Initialisation de la scène
+
+    if(scene.initialiserFenetre() == false)
+	return -1;
+
+    if(scene.initGL() == false)
+	return -1;
+
+
+    // Boucle Principale
+
+    scene.bouclePrincipale();
+
+
+    // Fin du programme
+
+    return 0;
+}