SFML with openGL: SFML does not render (but openGL does)

[Crafter]

Hi

I am trying to get through these openGL-Tutorials combining them with openGL: http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices/

The program draws a triangle on the screen, but the SFML rectangle does not draw. Why?
Is there a problem using glew?

Thanks in advance



Edit:
Rendering on a sf::RenderTexture and binding it to an openGL-Object and then rendering the object with the texture with openGL seems to work. Is this a possible workaround or stupid?


Everything before the main loop:

(click to show/hide)

        // Request a 24-bits depth buffer when creating the window
        ContextSettings contextSettings;
        contextSettings.depthBits = 24;

        // Create the main window
        RenderWindow window(VideoMode(800, 600), "SFML graphics with OpenGL", Style::Default, contextSettings);
        window.setVerticalSyncEnabled(true);

       
        // SFML loading
        RectangleShape rect;
        rect.setSize(Vector2f(100, 100));
        rect.setFillColor(Color::Green);


        // Make the window the active target for OpenGL calls
        // Note: If using Texture or Shader with OpenGL,
        // be sure to call Texture::getMaximumSize() and/or
        // Shader::isAvailable() at least once before calling
        // setActive(), as those functions will cause a context switch
        window.setActive();

        GLenum err = glewInit();
        if(err != GLEW_OK)
        {
                // Problem: glewInit failed, something is seriously wrong.
                fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        }
        fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

        // Create and compile our GLSL program from the shaders
        GLuint programID = LoadShaders("vertexShader.vertexshader", "fragmentShader.fragmentshader");


        glViewport(0, 0, window.getSize().x, window.getSize().y);
        glClearColor(0.0f, 0.0f, 0.9f, 0.5f);


        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);




        // Projection matrix : 45° Field of View, display range : 0.1 unit <-> 100 units
        glm::mat4 Projection = glm::perspective(glm::radians(45.0f), (float)window.getSize().x / (float)window.getSize().y, 0.1f, 100.0f);

        // Or, for an ortho camera :
        //glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f); // In world coordinates

        // Camera matrix
        glm::mat4 View = glm::lookAt(
                glm::vec3(4, 3, 3), // Camera is at (4,3,3), in World Space
                glm::vec3(0, 0, 0), // and looks at the origin
                glm::vec3(0, 1, 0)  // Head is up (set to 0,-1,0 to look upside-down)
                );

        // Model matrix : an identity matrix (model will be at the origin)
        glm::mat4 Model = glm::mat4(1.0f);

        // Our ModelViewProjection : multiplication of our 3 matrices
        glm::mat4 mvp = Projection * View * Model;

        // Get a handle for our "MVP" uniform
        // Only during the initialisation
        GLuint MatrixID = glGetUniformLocation(programID, "MVP");
 

main loop:

        while(window.isOpen())
        {
                Event event;
                while(window.pollEvent(event))
                {
                        if(event.type == Event::Closed)
                                window.close();
                        if((event.type == Event::KeyPressed) && (event.key.code == Keyboard::Escape))
                                window.close();
                        if(event.type == Event::Resized)
                                glViewport(0, 0, event.size.width, event.size.height);
                }

                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

                // Use our shader
                glUseProgram(programID);

                // Send our transformation to the currently bound shader, in the "MVP" uniform
                // This is done in the main loop since each model will have a different MVP matrix (At least for the M part)
                glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &mvp[0][0]);

                // 1rst attribute buffer : vertices
                glEnableVertexAttribArray(0);
                glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
                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
                        );
                // Draw the triangle !
                glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -> 1 triangle
                glDisableVertexAttribArray(0);



                window.pushGLStates();
                window.draw(rect);
                window.popGLStates();

                window.display();
        }

 

Simple shaders:

(click to show/hide)

vertex:

#version 330 core

// Input vertex data, different for all executions of this shader.
 layout(location = 0) in vec3 vertexPosition_modelspace;

 // Values that stay constant for the whole mesh.
 uniform mat4 MVP;

 void main()
 {
     // Output position of the vertex, in clip space : MVP * position
     gl_Position =  MVP * vec4(vertexPosition_modelspace, 1);
 }
 

fragment:

#version 330 core

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

[Mr_Blame]

what about checking for errors? Which video Card you have?

[Crafter]

I do not get any errors.
My video card: ATI Mobility Radeon HD 5850

glGetError() returns 0.
It just looks like

                window.pushGLStates();
                window.draw(rect);
                window.popGLStates();
 

is beeing ignored.


On Intel(R) HD Graphics:

window.draw(rect);

throws exception at 0x101290D7 (ig4icd32.dll)
access violation reading at position 0x066AEC70

[Crafter]

Does

window.pushGLStates();
window.draw(rect);
window.popGLStates();
 

maybe not do enough?


Adding

glBindVertexArray(GL_NONE);
glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);
 

makes it work:

// end of main loop

glBindVertexArray(GL_NONE);
glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);

window.pushGLStates();
window.draw(rect);
window.popGLStates();
 

[Laurent]

SFML push/pop only takes care of OpenGL 1.x states. States that require a higher GL core version are up to you.

[Crafter]

ok thanks
Would you please add this to the tutorial?
http://www.sfml-dev.org/tutorials/2.3/window-opengl.php
This could be helpful; thank you!

I want to use SFML for the 2D user interface.
Whis way is faster?
Rendering SFML into a RenderTexture, getting its texture and binding it to openGL and rendering two trianglas forming a plane over the window with them,
oder switching the contexts using window.push/pop glStates?

[Jesper Juhl]

Why don't you try both and measure the performance yourself?

[Crafter]

Seems like its only laborious.
(At least within a small test)