Comment dessiner pendant le redimensionnement d'une fenêtre

Question

Chaque fois que je redimensionne une fenêtre OpenGL, elle ne dessine pas lorsque je redimensionne la fenêtre. La partie de la fenêtre qui vient d'être exposée n'est dessinée qu'une fois le redimensionnement de la fenêtre terminé. Vous pouvez voir par vous-même dans l'image ci-dessous:

Voici le code pour mon application. Je cours Windows 10 sur Visual Studio 2015

#include <glad/glad.h> 
#include <GLFW/glfw3.h> 
#include <iostream> 

void framebuffer_size_callback(GLFWwindow* window, int width, int height); 
void processInput(GLFWwindow *window); 
void get_resolution(int* window_width, int* window_height); 
void initGlfwSettings(); 
GLFWwindow* initGlfwWindow(); 
void initGlad(); 

// settings 
const unsigned int SCR_WIDTH = 800; 
const unsigned int SCR_HEIGHT = 600; 

int main() 
{ 
    initGlfwSettings(); 

    GLFWwindow* window = initGlfwWindow(); 

    initGlad(); 

    // glad: load all OpenGL function pointers 
    // --------------------------------------- 


    // render loop 
    // ----------- 
    while (!glfwWindowShouldClose(window)) 
    { 
     int width, height; 
     glfwGetWindowSize(window, &width, &height); 


     glClearColor(0.2f, 0.3f, 0.3f, 1.0f); 
     glClear(GL_COLOR_BUFFER_BIT); 

     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 
     // input 
     // ----- 
     processInput(window); 

     // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.) 
     // ------------------------------------------------------------------------------- 
     glfwSwapBuffers(window); 
     glfwPollEvents(); 
    } 

    // glfw: terminate, clearing all previously allocated GLFW resources. 
    // ------------------------------------------------------------------ 
    glfwTerminate(); 
    return 0; 
} 

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly 
// --------------------------------------------------------------------------------------------------------- 
void processInput(GLFWwindow *window) 
{ 
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) 
     glfwSetWindowShouldClose(window, true); 
} 

// glfw: whenever the window size changed (by OS or user resize) this callback function executes 
// --------------------------------------------------------------------------------------------- 
void framebuffer_size_callback(GLFWwindow* window, int width, int height) 
{ 
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays. 
    glViewport(0, 0, width, height); 
} 

void get_resolution(int* window_width, int* window_height) { 
    const GLFWvidmode * mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); 

    *window_width = mode->width; 
    *window_height = mode->height; 
} 

void initGlfwSettings() 
{ 
    // glfw: initialize and configure 
    // ------------------------------ 
    glfwInit(); 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); 
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 


    #ifdef __APPLE__ 
     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X 
    #endif 
} 

GLFWwindow* initGlfwWindow() 
{ 
    /*GLFWmonitor* monitor = glfwGetPrimaryMonitor(); 
    int width; 
    int height; 

    get_resolution(&width, &height);*/ 



    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "learning opengl", NULL, NULL); 
    if (window == NULL) 
    { 
     std::cout << "Failed to create GLFW window" << std::endl; 
     glfwTerminate(); 
     exit(1); 
    } 

    glfwMakeContextCurrent(window); 
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 
    glfwSwapInterval(1); 

    return window; 
} 

void initGlad() 
{ 
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) 
    { 
     std::cout << "Failed to initialize GLAD" << std::endl; 
     exit(1); 
    } 
} 

Expliquer toutes les solutions à ce problème.

Answer 1

Il s'agit du gestionnaire d'événements Windows qui ne retourne pas le contrôle au thread principal. C'est comment fonctionne Windows et vous ne pouvez pas le changer.

Vous pouvez cependant déplacer toutes vos commandes de rendu et de commande glfw vers un thread différent, qui ne sera pas bloqué par Windows.