Ubuntu-fr

Lolichou

GLSL version 3 non supportée.

Salut, j'ai essayé d'utiliser les vbo avec opengl en suivant ce tutoriel :

Opengl moderne

Mais lors de la compilation du shader j'ai une erreur et il me dit que seul les versions 1.0, 1.1, 1.2 et 1.3 du glsl sont supportée.

Hors que la version que j'aie de opengl est supérieur à la version 3 car glEnableClientState ne fonctionne pas lorsque je bind ma vbo, c'est pour cela que je suis passé sur ce tutoriel d'ailleurs afin de faire ça avec glVertexAttribPointer plutôt que avec glVertexPointer, glColorPointer, etc...

Ca fonctionne :

#include <SFML/Graphics.hpp>
#include <glew.h>
#include <SFML/OpenGL.hpp>
#include <fstream>
GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path){

    // Create the shaders
    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

    // Read the Vertex Shader code from the file
    std::string VertexShaderCode;
    std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
    if(VertexShaderStream.is_open())
    {
        std::string Line = "";
        while(getline(VertexShaderStream, Line))
            VertexShaderCode += "\n" + Line;
        VertexShaderStream.close();
    }

    // Read the Fragment Shader code from the file
    std::string FragmentShaderCode;
    std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
    if(FragmentShaderStream.is_open()){
        std::string Line = "";
        while(getline(FragmentShaderStream, Line))
            FragmentShaderCode += "\n" + Line;
        FragmentShaderStream.close();
    }

    GLint Result = GL_FALSE;
    int InfoLogLength;

    // Compile Vertex Shader
    printf("Compiling shader : %s\n", vertex_file_path);
    char const * VertexSourcePointer = VertexShaderCode.c_str();
    glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
    glCompileShader(VertexShaderID);

    // Check Vertex Shader
    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    std::vector<char> VertexShaderErrorMessage(InfoLogLength);
    glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
    fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]);

    // Compile Fragment Shader
    printf("Compiling shader : %s\n", fragment_file_path);
    char const * FragmentSourcePointer = FragmentShaderCode.c_str();
    glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
    glCompileShader(FragmentShaderID);

    // Check Fragment Shader
    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    std::vector<char> FragmentShaderErrorMessage(InfoLogLength);
    glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
    fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]);

    // Link the program
    fprintf(stdout, "Linking program\n");
    GLuint ProgramID = glCreateProgram();
    glAttachShader(ProgramID, VertexShaderID);
    glAttachShader(ProgramID, FragmentShaderID);
    glLinkProgram(ProgramID);

    // Check the program
    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
    std::vector<char> ProgramErrorMessage(std::max(InfoLogLength, int(1)) );
    glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
    fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);

    glDeleteShader(VertexShaderID);
    glDeleteShader(FragmentShaderID);

    return ProgramID;
}
int main()
{
    // create the window
    sf::Window window(sf::VideoMode(800, 600), "My window", sf::Style::Default, sf::ContextSettings(32));
    glewInit();
    GLuint VertexArrayID;
    glGenVertexArrays(1, &VertexArrayID);
    glBindVertexArray(VertexArrayID);
    static const GLfloat g_vertex_buffer_data[] = {
       -1.0f, -1.0f, 0.0f,
       1.0f, -1.0f, 0.0f,
       0.0f,  1.0f, 0.0f,
    };

    // This will identify our vertex buffer
    GLuint vertexbuffer;
    // Generate 1 buffer, put the resulting identifier in vertexbuffer
    glGenBuffers(1, &vertexbuffer);
    // The following commands will talk about our 'vertexbuffer' buffer
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

    // Give our vertices to OpenGL.
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
    //Unbind the buffer.
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    // Create and compile our GLSL program from the shaders
    GLuint programID = LoadShaders( "SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader" );
    // run the program as long as the window is open
    glBindAttribLocation(programID, 0, "vertexPosition_modelspace");
    while (window.isOpen())
    {
        // check all the window's events that were triggered since the last iteration of the loop
        sf::Event event;
        while (window.pollEvent(event))
        {
            // "close requested" event: we close the window
            if (event.type == sf::Event::Closed)
                window.close();
            else if (event.type == sf::Event::Resized)
                // adjust the viewport when the window is resized
                glViewport(0, 0, event.size.width, event.size.height);
        }

        // clear the window with black color
        glClear(GL_COLOR_BUFFER_BIT);
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        //const char* data = reinterpret_cast<const char*>(&vertices[0]);
        glVertexAttribPointer(
           0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
           3,                  // size
           GL_FLOAT,           // type
           GL_FALSE,           // normalized?
           0,                  // stride
           (void*)0            // array buffer offset
        );
        // Use our shader
        glUseProgram(programID);
        // Draw the triangle !
        glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -> 1 triangle

        glDisableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        // draw everything here...
        // window.draw(...);

        // end the current frame
        window.display();
    }
    glDeleteBuffers(1, &vertexbuffer);
    return 0;
}

J'ai essayé d'installé les driver propriétaire mais ça ne fonctionne pas (mon programme crash) et apparemment ce n'est pas très recommandé de les utiliser sur ubuntu, du coup j'ai modifié le vertex shader et le fragment shader du programme et là ça marche :

#version 130
attribute vec3 vertexPosition_modelspace;
void main() {
    gl_Position.xyz = vertexPosition_modelspace;
    gl_Position.w = 1.0; 
}

#version 130
out vec3 color;
 
void main(){
    color = vec3(1,0,0);
}

J'ai bien un triangle rouge qui s'affiche, mais, à quand le support de glsl 3 sur ubuntu ?

Ma carte graphique est une ATI Mobility Radeon HD 5470. (Est ce déjà trop ancien ?)

Car j'ai acheté mon PC il y a plus de 3 ans.

Eldermê

Re : GLSL version 3 non supportée.

Bonjour,

Les dernières versions du driver libre radeon supportent OpenGL 3.3 (donc des shaders GLSL compilés en #version330) dès que le hardware le supporte (ce qui est bien le cas de ta carte) : xorg.freedesktop.org/wiki/RadeonFeature/
J'ai récemment fait marcher un bout de code OpenGL 3.3 sur ma Debian Sid avec le driver libre. Je ne sais pas où en est Ubuntu, mais  il y a des chances que les versions des paquets soient assez proches et que ça puisse aussi marcher chez toi.

Si tu tapes cette commande dans un terminal, ça te renvoie quoi ?

glxinfo | grep "OpenGL version"

Ensuite, dans ton application, il faut t'assurer que tu crées bien un contexte OpenGL 3.3. Pour le savoir, utilise glGetString(GL_VERSION).

Chez moi, j'avais besoin de demander un contexte "core" pour avoir de l'OpenGL 3.3. Par défaut, j'avais un contexte "compatibility" avec OpenGL 3.1, du coup impossible de compiler des shaders en GLSL 330. Il est possible que ce soit le même soucis chez toi. Par contre, le fait d'avoir un contexte "core" empêche d'utiliser les fonctionnalités obsolètes.

J'utilise SDL qui permet de demander explicitement un contexte OpenGL 3.3 core. Apparement tu utilises SFML, je suppose que c'est possible aussi.

---

Mon blog : petit projet de jeux en 3D (libres, bien sûr).