[SOLVED] Mix RenderWindow with OpenGL

[Lauthai]

Hello everyone,

I am working on programming a game in which there are two threads, Thread A (which renders using SFML based calls to draw) and Thread B (which uses direct OpenGL based calls).  What happens is that I draw some text on screen in Thread A, then pause and switch to Thread B where I draw a Purple Triangle with a blue background.  When it switches back from Thread B to Thread A and tries to draw using SFML again, the purple triangle persists and the text does not appear.  This triangle then stays on screen forever and nothing overrides it.  I am using a RenderWindow when creating my window for the game.  I believe that I am missing some call that is needed to switch from OpenGL back to SFML but I am not sure what it is.  Maybe it is something else I am missing.

I went and created a fresh .cpp file that contains only the base code needed to run this example.  Each Thread runs for 3 seconds then switches (mostly documented in code) and if you run the code, the ESC key is a kill key as it runs in full screen.

(click to show/hide)

#include <GL/glew.h>
#include <iostream>
#include <SFML/Graphics.hpp>
#include <thread>
using namespace std;

//Forward Declarations
void renderingThread(sf::RenderWindow* window);
void rThread(sf::RenderWindow* window);

std::chrono::milliseconds timespan(1000);

bool openGLInitialized = false;
GLuint shader_program = 0;
GLuint vbo = 0;
GLuint vao = 0;

void GLAPIENTRY
MessageCallback(GLenum source,
        GLenum type,
        GLuint id,
        GLenum severity,
        GLsizei length,
        const GLchar* message,
        const void* userParam)
{
        fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
                (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
                type, severity, message);
}

int main() {

        // Create the window
        sf::RenderWindow gameWindow(sf::VideoMode(1920, 1080), "Game", sf::Style::Fullscreen);

        // Enable Glew
        glewExperimental = GL_TRUE;
        if (GLEW_OK != glewInit()) {
                cerr << "Failed to initialize GLEW";
                exit(-1);
        }
        else {
                cout << " > OpenGL Version:  " << (const char*)glGetString(GL_VERSION) << endl;
                cout << " > GLSL Version:    " << (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
                cout << " > OpenGL Vendor:   " << (const char*)glGetString(GL_VENDOR) << endl;
                cout << " > OpenGL Renderer: " << (const char*)glGetString(GL_RENDERER) << endl << endl;
               
                // During init, enable debug output
                glEnable(GL_DEBUG_OUTPUT);
                glDebugMessageCallback(MessageCallback, 0);
        }

        // Set some stuff for the window
        gameWindow.setKeyRepeatEnabled(false);
        gameWindow.setMouseCursorVisible(false);
        gameWindow.setActive(false);

        // Being the rendering thread
        sf::Thread thread(&renderingThread, &gameWindow);
        thread.launch();

        // Poll Events
        while (gameWindow.isOpen()) {
                sf::Event evnt;
                while (gameWindow.pollEvent(evnt)) {
                        if (evnt.type == sf::Event::Closed) {
                                gameWindow.close();
                        }

                        // Easy ESC kill command
                        if (evnt.type == sf::Event::KeyPressed) {
                                if (evnt.key.code == sf::Keyboard::Escape) {
                                        exit(0);
                                }
                        }
                }
        }

        return 0;
}

void renderingThread(sf::RenderWindow* gameWindow) {
        // Do rendering here

        // Set screen renderer to active in this thread
        gameWindow->setActive(true);

        // Load a font
        sf::Font basicFont;
        if (!basicFont.loadFromFile("Fonts/HonyaJi-Re.ttf")) {
                cerr << "Error loading font" << endl;
                exit(0);
        }

        // Render loop
        while (gameWindow->isOpen()) {

                cout << "SFML - BEFORE" << endl;

                // Draw some basic text on screen using SFML
                sf::Text countdownText;
                countdownText.setCharacterSize(36);
                countdownText.setFillColor(sf::Color::White);
                countdownText.setFont(basicFont);
                countdownText.setPosition(500.f, 500.f);
                for (int i = 3; i > 0; i--) {
                        gameWindow->clear();
                        countdownText.setString("SFML-Before | " + to_string(i));
                        gameWindow->draw(countdownText);
                        gameWindow->display();
                        this_thread::sleep_for(timespan);
                }

                // Switch over to OpenGL rendering in a different thread
                gameWindow->clear();
                gameWindow->setActive(false);
                sf::Thread thread(&rThread, gameWindow);
                thread.launch();
                thread.wait();

                cout << "SFML - AFTER" << endl;

                // After returning back, draw in SFML again
                gameWindow->setActive(true);
                sf::Text countdownText2;
                countdownText2.setCharacterSize(36);
                countdownText2.setFillColor(sf::Color::White);
                countdownText2.setFont(basicFont);
                countdownText2.setPosition(500.f, 500.f);
                for (int i = 3; i > 0; i--) {
                        gameWindow->clear();
                        countdownText2.setString("SFML-After | " + to_string(i));
                        gameWindow->draw(countdownText2);
                        gameWindow->display();
                        this_thread::sleep_for(timespan);
                }
        }
}

void rThread(sf::RenderWindow* window) {

        window->setActive(true);

        if (!openGLInitialized) {
                openGLInitialized = true;

                // Triangle vertices
                float points[] = {
                         0.0f,  0.5f,  0.0f,
                         0.5f, -0.5f,  0.0f,
                        -0.5f, -0.5f,  0.0f
                };

                // Pass vertices into VBO
                glGenBuffers(1, &vbo);
                glBindBuffer(GL_ARRAY_BUFFER, vbo);
                glBufferData(GL_ARRAY_BUFFER, 9 * sizeof(float), points, GL_STATIC_DRAW);

                // Build VAO
                glGenVertexArrays(1, &vao);
                glBindVertexArray(vao);
                glEnableVertexAttribArray(0);
                glBindBuffer(GL_ARRAY_BUFFER, vbo);
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

                // Vertex Shader
                const char* vertex_shader =
                        "#version 400\n"
                        "in vec3 vp;"
                        "void main() {"
                        "  gl_Position = vec4(vp, 1.0);"
                        "}";

                // Fragment Shader
                const char* fragment_shader =
                        "#version 400\n"
                        "out vec4 frag_colour;"
                        "void main() {"
                        "  frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
                        "}";

                // Compile shaders
                GLuint vs = glCreateShader(GL_VERTEX_SHADER);
                glShaderSource(vs, 1, &vertex_shader, NULL);
                glCompileShader(vs);
                GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
                glShaderSource(fs, 1, &fragment_shader, NULL);
                glCompileShader(fs);

                // Link and attach shaders
                shader_program = glCreateProgram();
                glAttachShader(shader_program, fs);
                glAttachShader(shader_program, vs);
                glLinkProgram(shader_program);

                glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        }

        cout << "OpenGL" << endl;

        int i = 3;
        while (i > 0) {
                // Draw OpenGL
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                glUseProgram(shader_program);
                glBindVertexArray(vao);

                // Draw points 0-3 from the currently bound VAO with
                // current in-use shader
                glDrawArrays(GL_TRIANGLES, 0, 3);

                window->display();

                i--;
                this_thread::sleep_for(timespan);
        }

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        window->setActive(false);
}

 

I am using the latest version of SFML and GLEW to run this .cpp example file.  I have attached the .cpp file (which is the code in the spoiler above)

Please let me know if there is something that I missed in my code that causes it to not be able to switch back from OpenGL drawing to SFML drawing.

[eXpl0it3r]

I don't see how threads help with anything you're doing here, instead they raise complexity by a lot and require special handling for OpenGL contexts.
You should instead really just be using one thread (see also this explanation). See also this tutorial on how to mix SFML with OpenGL.

Finally, I'd suggest to use Glad or similar to load OpenGL functions instead of GLEW.

[Lauthai]

I know the threads seem very convoluted and even complicate things, but that's the way the program I am making runs everything.  I was about to find a solution over on this thread: https://en.sfml-dev.org/forums/index.php?topic=24081.0 Where after my while loop that ends around line 217 in the second thread, I needed to add

glBindVertexArray(0);
window->pushGLStates();
 

I needed to do additional clean up before returning out of Thread B.  But those lines did fix the problem.