Import shader testing project

shaderTest/ColorCube.cpp

@@ -0,0 +1,108 @@
+#include "ColorCube.h"
+static unsigned int s_nbColorCubes=0;
+
+// Constructeur et Destructeur
+ColorCube::ColorCube()
+{
+    // Incrémentation du nombre de cubes
+    s_nbColorCubes++;
+
+    // Vertices
+    float verticesTmp[42] = {0.0f,0.0f,1.0f,   1.0f,1.0f,1.0f,   1.0f,0.0f,1.0f,  1.0f,0.0f,0.0f,  0.0f,0.0f,1.0f,  0.0f,0.0f,0.0f,        0.0f,1.0f,0.0f,
+                        1.0f,0.0f,0.0f,    1.0f,1.0f,0.0f,    1.0f,1.0f,1.0f,    0.0f,1.0f,0.0f,    0.0f,1.0f,1.0f,    0.0f,0.0f,1.0f,      1.0f,1.0f,1.0f};
+    for(int i(0); i < 42; i++)
+        m_vertices[i] = verticesTmp[i];
+
+    // Couleurs
+    float couleursTmp[42] = {1.0,1.0,0.0,     1.0,0.0,0.0,   1.0,0.0,0.0,   0.0,0.0,1.0,    1.0,1.0,0.0,     0.0,1.0,0.0,           0.0,1.0,0.0,
+                            0.0,0.0,1.0,      0.0,0.0,1.0,      1.0,0.0,0.0,      0.0,1.0,0.0,      1.0,1.0,0.0,      1.0,1.0,0.0,     1.0,0.0,0.0};
+    for (int i(0); i<42; i++)
+        m_couleurs[i] = couleursTmp[i];
+}
+
+
+ColorCube::ColorCube(float taille, float red, float green, float blue)
+{
+    // Incrémentation du nombre de cubes
+    s_nbColorCubes++;
+
+    // Vertices
+    float verticesTmp[42] = {0.f,0.0f,taille,   taille,taille,taille,   taille,0.0f,taille,  taille,0.0f,0.0f,  0.0f,0.0f,taille,  0.0f,0.0f,0.0f,        0.0f,taille,0.0f,
+                        taille,0.0f,0.0f,    taille,taille,0.0f,    taille,taille,taille,    0.0f,taille,0.0f,    0.0f,taille,taille,    0.0f,0.0f,taille,      taille,taille,taille};
+    for(int i(0); i < 42; i++)
+        m_vertices[i] = verticesTmp[i];
+
+    // Couleurs
+    setColor(red,green,blue);
+}
+
+
+ColorCube::~ColorCube()
+{
+    s_nbColorCubes--;
+}
+
+
+// Méthodes
+void ColorCube::setColor(float red, float green, float blue)
+{
+    // Attribution des couleurs
+    for(int i(0); i < 42; i++)
+    {
+        switch (i%3)
+        {
+            case 0:
+                m_couleurs[i] = red;
+                break;
+            case 1:
+                m_couleurs[i] = green;
+                break;
+            case 2:
+                m_couleurs[i] = blue;
+                break;
+        }
+    }
+}
+
+void ColorCube::afficher()
+{
+    // 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);
+
+    // Rendu
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 14);
+
+    // Désactivation des tableaux
+    glDisableVertexAttribArray(1);
+    glDisableVertexAttribArray(0);
+}
+
+void ColorCube::move(glm::vec3 deplacement)
+{
+    for(int i(0); i < 42; i++)
+    {
+        switch (i%3)
+        {
+            case 0:
+                m_vertices[i] += deplacement.x;
+                break;
+            case 1:
+                m_vertices[i] += deplacement.y;
+                break;
+            case 2:
+                m_vertices[i] += deplacement.z;
+                break;
+        }
+    }
+}
+
+unsigned int getNbColorCubes()
+{
+    return s_nbColorCubes;
+}
+

shaderTest/ColorCube.h

@@ -0,0 +1,41 @@
+#ifndef DEF_COLORCUBE
+#define DEF_COLORCUBE
+
+
+// Includes OpenGL
+#ifdef WIN32
+#include <GL/glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+#endif
+
+// Includes GLM
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+
+// Classe ColorCube
+class ColorCube
+{
+    public:
+
+    ColorCube();
+    ColorCube(float taille, float red, float green, float blue);
+    ~ColorCube();
+
+    void setColor(float red, float green, float blue);
+    void afficher();// Vérouiller un shader et lui envoyer projection et modelview avant
+
+    void move(glm::vec3 deplacement);
+
+    private:
+
+    float m_vertices[42];
+    float m_couleurs[42];
+};
+unsigned int getNbColorCubes();
+
+#endif

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

shaderTest/Input.h

@@ -0,0 +1,49 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+// Include
+
+#include <SDL2/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
+

shaderTest/Mosaic.cpp

@@ -0,0 +1,97 @@
+#include "Mosaic.h"
+
+//Constructeurs et destructeurs
+Mosaic::Mosaic(std::string const vertexShader, std::string const fragmentShader, std::string const fichierImg, Uint8 redMask, Uint8 greenMask, Uint8 blueMask)
+:m_shader(vertexShader, fragmentShader)
+{
+    /// Chargement de l'image
+    SDL_Surface* image = SDL_LoadBMP(fichierImg.c_str());
+
+    /// Attribution des couleurs
+    if (image!=0)
+    {
+        // Préaparation des variables d'info et de manip
+        unsigned char* pixels = (unsigned char*) image->pixels;
+        Uint8 taille(image->format->BytesPerPixel);
+        Uint32 ligne(DIM*taille);
+        Uint8 red,green,blue,addRed,addBlue;
+        if(image->format->Rmask == 0xff){
+            addRed = 0;
+            addBlue = 2;
+        }
+        else{
+            addRed = 2;
+            addBlue = 0;
+        }
+
+        // Libération de la mémoire
+        SDL_FreeSurface(image);
+
+        // Balayage
+        for (int y(0); y<DIM; y++)
+            for (int x(0); x<DIM; x++)
+            {
+                // Chargement des couleurs
+                red = pixels[(ligne*y)+x*taille+addRed];
+                green = pixels[(ligne*y)+x*taille+1];
+                blue = pixels[(ligne*y)+x*taille+addBlue];
+
+                // Voxel non-affiché
+                if (red==redMask && green==greenMask && blue==blueMask)
+                    m_opaque[DIM-y-1][x]=false;
+
+                // Voxel affiché : attribution des couleurs
+                else
+                {
+                    m_opaque[DIM-y-1][x]=true;
+                    m_mosaic[DIM-y-1][x].setColor((float)red/255.0f,(float)green/255.0f,(float)blue/255.0f);
+                }
+
+            }
+    }
+    else
+        std::cout <<"Impossible de charger "<<fichierImg<<" dans Mosaic."<< std::endl;
+
+    /// Shader
+    m_shader.charger();
+
+    /// Placement des cubes
+    glm::vec3 deplacement(-DIM/2,-DIM/2,-0.5f);
+    for (int y(0); y<DIM; y++)
+    {
+        for (int x(0); x<DIM; x++)
+        {
+            m_mosaic[y][x].move(deplacement);
+            deplacement.x++;
+        }
+        deplacement.y++;
+        deplacement.x=-DIM/2;
+    }
+}
+
+Mosaic::~Mosaic()
+{
+
+}
+
+
+//Méthodes
+void Mosaic::afficher(glm::mat4 &projection, glm::mat4 modelview)
+{
+    /// OpenGL verrouillages
+    // Activation du shader
+    glUseProgram(m_shader.getProgramID());
+    // Envoi des matrices
+    glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "projection"), 1, GL_FALSE, glm::value_ptr(projection));
+    glUniformMatrix4fv(glGetUniformLocation(m_shader.getProgramID(), "modelview"), 1, GL_FALSE, glm::value_ptr(modelview));
+
+    /// Balayage
+    for (int y(0); y<DIM; y++)
+        for (int x(0); x<DIM; x++)
+            if(m_opaque[y][x])
+                m_mosaic[y][x].afficher();
+
+    /// OpenGL déverrouillages
+    // Désactivation du shader
+    glUseProgram(0);
+}

shaderTest/Mosaic.h

@@ -0,0 +1,43 @@
+#ifndef MOSAIC_H_INCLUDED
+#define MOSAIC_H_INCLUDED
+
+// Includes OpenGL
+#ifdef WIN32
+#include <GL/glew.h>
+
+#else
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+#endif
+
+// Includes GLM
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// Includes
+#include <SDL2/SDL.h>
+#include <iostream>
+#include "ColorCube.h"
+#include "Shader.h"
+
+#define DIM 32
+
+class Mosaic
+{
+    public:
+
+        Mosaic(std::string const vertexShader, std::string const fragmentShader, std::string const fichierImg, Uint8 redMask, Uint8 greenMask, Uint8 blueMask);
+        ~Mosaic();
+
+        void afficher(glm::mat4 &projection, glm::mat4 modelview);
+
+    private:
+
+        Shader m_shader;
+
+        ColorCube m_mosaic[DIM][DIM];//y;x
+        bool m_opaque[DIM][DIM];
+};
+
+#endif // MOSAIC_H_INCLUDED

shaderTest/SceneOpenGL.cpp

@@ -0,0 +1,169 @@
+#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)
+{
+
+}
+
+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_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()
+{
+    //glEnable(GL_DEPTH_TEST);
+    return true;
+}
+
+void SceneOpenGL::bouclePrincipale()
+{
+    // Shader
+    Shader shader("Shaders/basique2D.vert", "Shaders/basique2D.frag");
+    shader.charger();
+
+    // Vertices
+    float vertices[] = {-0.5, -0.5,   0.5, -0.5,   0.5, 0.5,    // Triangle 1
+                        -0.5, -0.5,   -0.5, 0.5,   0.5, 0.5};   // Triangle 2
+
+    /* ***** Gestion du VBO ***** */
+    GLuint vbo;
+    int tailleVerticesBytes = 12 * sizeof(float);
+
+    // Génération du VBO
+    glGenBuffers(1, &vbo);
+
+    // Verrouillage
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+        // Remplissage
+        glBufferData(GL_ARRAY_BUFFER, tailleVerticesBytes, 0, GL_STATIC_DRAW);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, tailleVerticesBytes, vertices);
+
+    // Déverrouillage
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    /* ***** Gestion du VAO ***** */
+    GLuint vao;
+
+    // Génération du VAO
+    glGenVertexArrays(1, &vao);
+
+    // Verrouillage du VAO
+    glBindVertexArray(vao);
+
+        // Verrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+            // Vertex Attrib 0 (Vertices)
+            glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
+            glEnableVertexAttribArray(0);
+
+        // Déverrouillage du VBO
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    // Déverrouillage du VAO
+    glBindVertexArray(0);
+
+    // Variables relatives au framerate
+    unsigned int frameRate (1000 / 50);
+    Uint32 debutBoucle(0), finBoucle(0), tempsEcoule(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;
+
+        // Nettoyage de l'écran
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Shader verrouillé
+        glUseProgram(shader.getProgramID());
+
+            // Verrouillage du VAO
+            glBindVertexArray(vao);
+
+            // Rendu
+            glDrawArrays(GL_TRIANGLES, 0, 6);
+
+            // Déverrouillage du VAO
+            glBindVertexArray(0);
+
+        // Shader dévérouillé
+        glUseProgram(0);
+
+        // 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);
+    }
+
+    // Destruction du VAO et du VBO
+    glDeleteBuffers(1, &vbo);
+    glDeleteVertexArrays(1, &vao);
+}
+

shaderTest/SceneOpenGL.h

@@ -0,0 +1,50 @@
+#ifndef SCENEOPENGL_H_INCLUDED
+#define SCENEOPENGL_H_INCLUDED
+
+// Includes GLM
+#include <glm/glm.hpp>
+#include <glm/gtx/transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+// Includes OpenGL
+#include <SDL2/SDL.h>
+#define GL3_PROTOTYPES 1
+#include <GL3/gl3.h>
+
+//Includes de base
+#include <string>
+#include <iostream>
+
+//Autres includes
+#include "Shader.h"
+#include "Input.h"
+
+// Macro utile au VBO
+#ifndef BUFFER_OFFSET
+    #define BUFFER_OFFSET(offset) ((char*)NULL + (offset))
+#endif
+
+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;
+    Input m_input;
+};
+
+#endif // SCENEOPENGL_H_INCLUDED

shaderTest/Shader.cpp

@@ -0,0 +1,283 @@
+#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(m_vertexID!=0 && glIsShader(m_vertexID) == GL_TRUE)
+        glDeleteShader(m_vertexID);
+
+    if(m_fragmentID!=0 && glIsShader(m_fragmentID) == GL_TRUE)
+        glDeleteShader(m_fragmentID);
+
+    if(m_programID!=0 && 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;
+}
+
+bool Shader::chargerNouveauShader(std::string vertexSource, std::string fragmentSource)
+{
+    // Attribution du nouveau shader
+    m_vertexSource = vertexSource;
+    m_fragmentSource = fragmentSource;
+
+    // Chargement
+    return charger();
+}
+
+
+// Getter
+
+GLuint Shader::getProgramID() const
+{
+    return m_programID;
+}

shaderTest/Shader.h

@@ -0,0 +1,52 @@
+#ifndef DEF_SHADER
+#define DEF_SHADER
+
+///Jovian a ajouté Shader::bool chargerNouveauShader(std::string vertexSource, std::string fragmentSource);
+
+// Include Windows
+#ifdef WIN32
+#include <GL/glew.h>
+
+// Include Mac ou 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 chargerNouveauShader(std::string vertexSource, std::string fragmentSource);
+    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

shaderTest/Shaders/basique2D.frag

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

shaderTest/Shaders/basique2D.vert

@@ -0,0 +1,21 @@
+// Version du GLSL
+#version 150 core
+
+// Entrée Shader
+in vec2 in_Vertex;
+
+// Sorties
+out vec3 color;
+
+// Fonction main
+void main()
+{
+    // Position finale du vertex
+    gl_Position = vec4(in_Vertex, 0.0, 1.0);
+
+    // Transfert de couleurs
+    float value = 1.0-sqrt(in_Vertex.x*in_Vertex.x + in_Vertex.y*in_Vertex.y);
+    if (value<0.0)
+        value = 0.0;
+    color = vec3(value,value,0.0);
+}

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

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

shaderTest/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, 0.0);
+}

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

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

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

shaderTest/main.cpp

@@ -0,0 +1,13 @@
+#include <iostream>
+#include "SceneOpenGL.h"
+
+int main(int argc, char **argv)
+{
+    SceneOpenGL plateau("Shaders bidouillés !",768,768);
+    if (!plateau.initialiserFenetre() || !plateau.initGL())
+        return -1;
+
+    plateau.bouclePrincipale();
+
+    return 0;
+}