Show Posts

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

« on: February 07, 2016, 11:42:48 am »

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)

Topics - Crafter

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