Topics

1

Graphics / [SOLVED] Mix RenderWindow with OpenGL

« on: January 28, 2021, 07:48:19 am »

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.

2

Graphics / Unicode Text Appearing as Boxes With Question Marks

« on: September 13, 2020, 05:02:11 pm »

Hello,

I am trying to get unicode characters working inside of my sfml based program written in C++.  I have tried using a wide string but when it draws on screen, it appears as a box with a question mark inside of it.  I am using the Consolas font when drawing the text.  I have my console set to use the same font and it draws the characters fine, but can't when drawn on screen.

Here is a simplified version of the code I am running:

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

// gameWindow is passed over to a thread so now I have a reference via pointer

// Load the font
sf::Font basicFont;
if (!basicFont.loadFromFile("Fonts/consola.ttf")) {
        wcerr << L"Can't load text" << endl;
        return;
}

// Create the basic text
sf::Text test;
test.setFont(basicFont);
test.setString(L"君の魂");
test.setPosition(500.f,500.f);
test.setCharacterSize(40);
test.setFillColor(sf::Color::White);
gameWindow->draw(test);
 

The font is loaded successfully and that return statement never called.

I have also attached the consola.ttf since maybe there is a problem with that.

I'm not sure exactly why it is unable to draw those characters.

3

Audio / Music getPlayingOffset() more accurate?

« on: February 20, 2020, 11:40:05 pm »

I am working on a rhythm style game and am using sf::Music to load and play my song files.  However, when I try to use the getPlayingOffset().asMilliseconds() function, it only is producing updates to the number every 20 milliseconds. For example:

// Create and open a song file
sf::Music song;
song.openFromFile(gameState.getSongPlaying().getAudioFilePath());

song.play();

// Test by outputting the offset.
while(1) {
    cout << song.getPlayingOffset().asMilliseconds() << endl;
}
 

I would expect that it would output something continouous like 1, 2, 3, 4, ... but instead get 0, 0, ..., 0, 20, 20 and repeat by 20s.

Is there a way to make it so that the offset is more accurately outputting to the millisecond instead of 20? Would that involve modifying a compiling a custom copy of the audio.dll?  Or would you have a better suggestion to get the current millisecond since the start of the song (i.e. would output 1000 if the song has been going for 1 second)?

EDIT: Would it be better to load the song into a sound buffer and then play using sf::Sound instead? Would the reduce the update delay?