Caricamento risorse GLFW 3.0 con OpenGL

Question

Ho iniziato a entrare nella scena un po 'schiacciante del caricamento delle risorse OpenGL su un thread separato in modo che il thread principale possa continuare a eseguire il rendering di un oggetto. Quando si passa in, ho notato che GLFW rilasciato una versione aggiornata di un mese indietro con gestione del contesto più facile.

Tuttavia, con glfwMakeContextCurrent() mi sono stati in grado di rendere questo possibile. Nel thread loading uso questa funzione e dopo il suo completamento aggiungo nuovo modo che il filo principale riceve poi il contesto per ulteriore uso. Questo non mi consente di creare e compilare shader o qualsiasi altra creazione relativa a OpenGL.

aggiornamento:

Cosa deve essere fatto in modo da poter usare GLFW in questa situazione? Poiché GLFW è portatile, mi piacerebbe usare il codice che lo include. Non conosco i passaggi necessari per preparare un thread tenendo presente l'API GLFW.

Come post del blog afferma this, ho bisogno di creare due thread con un contesto OpenGL (non lo stesso contesto; D) e quindi condividere le informazioni. Tuttavia, le istruzioni mostrate sono specifiche della piattaforma. Come posso poi fare uso di GLFW così i passaggi della esempio sono indipendenti dalla piattaforma il più possibile?

Answer 1

utilizzare il parametro share su glfwCreateWindow():

#include <GL/glew.h> 
#include <GLFW/glfw3.h> 
#include <chrono> 
#include <thread> 
#include <atomic> 

// reload shared VBO with random data every second 
void MyThread(GLFWwindow* win, GLuint vbo, std::atomic<bool>& running) 
{ 
    glfwMakeContextCurrent(win); 
    glewInit(); 
    while(running) 
    { 
     float temp[ 512 ]; 
     for(size_t i = 0; i < 512; i+=2) 
     { 
      temp[ i+0 ] = static_cast<float>(rand() % 600); 
      temp[ i+1 ] = static_cast<float>(rand() % 600); 
     } 

     glBindBuffer(GL_ARRAY_BUFFER, vbo); 
     glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 512, temp, GL_DYNAMIC_DRAW); 
     glBindBuffer(GL_ARRAY_BUFFER, 0); 

     // oddly important, might need to be glFinish() 
     glFlush(); 

     std::this_thread::sleep_for(std::chrono::milliseconds(1000)); 
    } 
} 

int main(int argc, char** argv) 
{ 
    if(!glfwInit()) 
     return -1; 

    glfwWindowHint(GLFW_VISIBLE, GL_FALSE); 
    GLFWwindow* threadWin = glfwCreateWindow(1, 1, "Thread Window", NULL, NULL); 

    glfwWindowHint(GLFW_VISIBLE, GL_TRUE); 
    GLFWwindow* window = glfwCreateWindow(600, 600, "Hello World", NULL, threadWin); 
    glfwMakeContextCurrent(window); 
    glewInit(); 

    // load shared VBO with dummy data 
    float temp[ 512 ] = { 0 }; 
    GLuint vbo; 
    glGenBuffers(1, &vbo); 
    glBindBuffer(GL_ARRAY_BUFFER, vbo); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 512, temp, GL_DYNAMIC_DRAW); 
    glBindBuffer(GL_ARRAY_BUFFER, 0); 
    std::atomic<bool> running(true); 
    std::thread aThread(MyThread, threadWin, vbo, std::ref(running)); 

    while(!glfwWindowShouldClose(window)) 
    { 
     glfwPollEvents(); 

     glClear(GL_COLOR_BUFFER_BIT); 

     glMatrixMode(GL_PROJECTION); 
     glLoadIdentity(); 
     glOrtho(0, 600, 0, 600, -1, 1); 
     glMatrixMode(GL_MODELVIEW); 
     glLoadIdentity(); 

     glEnableClientState(GL_VERTEX_ARRAY); 
     glBindBuffer(GL_ARRAY_BUFFER, vbo); 
     glVertexPointer(2, GL_FLOAT, 0, 0); 
     glColor3ub(255, 0, 0); 
     glDrawArrays(GL_LINES, 0, 256); 
     glBindBuffer(GL_ARRAY_BUFFER, 0); 
     glDisableClientState(GL_VERTEX_ARRAY); 

     std::this_thread::sleep_for(std::chrono::milliseconds(10)); 
     glfwSwapBuffers(window); 
    } 

    running = false; 
    aThread.join(); 

    glfwTerminate(); 
    return 0; 
}