Seg fault while calling glfwSwapBuffers

Question

It seems that I am having a seg fault while using GLFW and OpenGL on ArchLinux, DWM (fully updated and patched).

I retraced the code and it is having the segFault in the glfwSwapBuffers(window).

Here is my code :

main.cpp

#include <iostream>
#include "gui/window.h"

int main(int, char**) {
    Window window("Test GL", 800, 600);

    if(!window.hasCorrectlyLoaded()) {
        return 1;
    }

    while (!window.shouldClose())
    {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        window.pollEvents();
    }
}

window.h

#ifndef __WINDOW_H__
#define __WINDOW_H__

#include <string>
#include <glad/gl.h>
#include <GLFW/glfw3.h>

class Window {
private:
    GLFWwindow *window;
    bool correctlyLoaded;

public:
    Window(const std::string&, int, int);
    ~Window();

    const bool hasCorrectlyLoaded();
    const bool shouldClose();

    const void pollEvents();
};

#endif // __WINDOW_H__

window.cpp

#include "window.h"
#include <spdlog/spdlog.h>

Window::Window(const std::string& title, int width, int height)
{
    correctlyLoaded = false;
    if(!glfwInit()) {
        spdlog::default_logger()->critical("Could not load GLFW");
        return;
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);

    GLFWwindow* window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr);
    if (!window)
    {
        spdlog::default_logger()->critical("Failed to create GLFW window !");
        return;
    }

    glfwMakeContextCurrent(window);

    if (!gladLoadGL(glfwGetProcAddress))
    {
        spdlog::default_logger()->critical("Failed to load OpenGL !");
        return;
    }

    spdlog::default_logger()->info("Loaded OpenGL {}", glfwGetVersionString());
    
    glViewport(0, 0, width, height);
    correctlyLoaded = true;
}

const void Window::pollEvents()
{
    glfwSwapBuffers(window);
    glfwPollEvents(); //<- Seg fault here
}

Window::~Window()
{
    glfwTerminate();
}

const bool Window::hasCorrectlyLoaded()
{
    return correctlyLoaded;
}

const bool Window::shouldClose()
{
    return glfwWindowShouldClose(window);
}

While further researching, I stumbled upon an answer that told me to set the glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API) window hint but I still got a segfault, but at a different place :

GLFW source code

GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
    _GLFWwindow* window = (_GLFWwindow*) handle;
    assert(window != NULL);

    _GLFW_REQUIRE_INIT();

    if (window->context.client == GLFW_NO_API)
    {
        _glfwInputError(GLFW_NO_WINDOW_CONTEXT,
                        "Cannot swap buffers of a window that has no OpenGL or OpenGL ES context"); //<- Seg fault without window hint
        return;
    }

    window->context.swapBuffers(window); //<- Seg fault with window hint
}

Here is the output I get from the logging :

[2022-05-24 20:01:04.252] [info] Loaded OpenGL 3.4.0 X11 GLX Null EGL OSMesa monotonic
[1]    432406 segmentation fault (core dumped)  /home/lygaen/code/testgl/build/testgl

Answer 1

Your problem occurs in Window.cpp, at this line:

//...
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);

GLFWwindow* window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr); //<---
if (!window)
{
//...

You've redeclared window as a local variable to this constructor, and as a result, the pointer never escapes the constructor, and is dangled.

A good habit when trying to assign class members is to use the this keyword. It is often redundant, but it does help indicate intent. So the code should be changed to this:

//...
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);

this->window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr); //<---
if (!this->window)
{
//...

If your style guidelines don't permit it, you can omit the this->; the only important part is that you're not declaring an entirely new variable that's shadowing the class member.