OpenGL Shader vec3 wird nicht aktualisiert

Question

Ich versuche, die Farbe des Dreiecks jeden Frame zu aktualisieren. Ich habe kein Glück und ich kann nicht herausfinden, warum jemand bitte mir helfen kann. Ich habe mehrere Male versucht, die Art zu ändern, wie ich es versuche um die Daten jedes Mal zu aktualisieren. Jede Hilfe würde geschätzt werden.

#include <glew.h> 
#include <glfw3.h> 
#include <iostream> 
#include <fstream> 
#include <time.h> 
using namespace std; 

GLuint compileshaders() { 
    GLuint vshader, fshader, program; 

    static const GLchar * vshadersource[] = { 
     "#version 450 core    \n" 
     " layout (location=0) in vec3 position;\n" 
     " layout (location=1) in vec3 color;\n" 
     " out vec3 color_out    ;\n" 
     "void main()     \n" 
     "{        \n" 
     "color_out = color;    \n" 
     "gl_Position = vec4(position,1.0);\n" 
     "}        \n" 
    }; 

    static const GLchar * fshadersource[] = { 
     "#version 450 core    \n" 
     "in vec3 color_out;    \n" 
     "out vec4 colorO;     \n" 
     "void main()      \n" 
     "{        \n" 
     " colorO = vec4(color_out,1.0); \n" 
     "}        \n" 
    }; 

    vshader = glCreateShader(GL_VERTEX_SHADER); 
    glShaderSource(vshader, 1, vshadersource, NULL); 
    glCompileShader(vshader); 

    fshader = glCreateShader(GL_FRAGMENT_SHADER); 
    glShaderSource(fshader, 1, fshadersource, NULL); 
    glCompileShader(fshader); 

    GLint vCompiled = 0; 
    glGetShaderiv(vshader, GL_COMPILE_STATUS, &vCompiled); 
    GLint fCompiled = 0; 
    glGetShaderiv(fshader, GL_COMPILE_STATUS, &fCompiled); 

    if (vCompiled && fCompiled != GL_FALSE) { 
     program = glCreateProgram(); 
     glAttachShader(program, vshader); 
     glAttachShader(program, fshader); 
     glLinkProgram(program); 
     glDeleteShader(vshader); 
     glDeleteShader(fshader); 
     return program; 
    } 
    else { 
     cout << "Shader Error!" << endl; 
    } 

    glDeleteShader(vshader); 
    glDeleteShader(fshader); 

    return NULL; 
} 

int main(void) 
{ 
    srand(time(0)); 
    GLFWwindow* window; 
    GLuint program; 
    GLuint vertex_array_object; 
    GLuint buffers[2]; 

    if (!glfwInit()) 
     return -1; 

    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL); 
    if (!window) 
    { 
     glfwTerminate(); 
     return -1; 
    } 

    glfwMakeContextCurrent(window); 

    glewInit(); 

    static const GLfloat positions[] = {0.25,-0.25,0.5,0.25,0.25,0.5,-0.25,-0.25,0.5}; 
    static GLfloat color[] = {1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0}; 

    program = compileshaders(); 
    glUseProgram(program); 
    glCreateVertexArrays(1, &vertex_array_object); 
    glCreateBuffers(2, &buffers[0]); 
    glNamedBufferStorage(buffers[0], sizeof(positions), positions, 0); 
    glVertexArrayVertexBuffer(vertex_array_object, 0, buffers[0], 0, sizeof(GLfloat) * 3); 
    glVertexArrayAttribFormat(vertex_array_object, 0, 3, GL_FLOAT, GL_FALSE, 0); 
    glVertexArrayAttribBinding(vertex_array_object, 0, 0); 
    glEnableVertexArrayAttrib(vertex_array_object, 0); 
    glNamedBufferStorage(buffers[1], sizeof(color), color, 0); 
    glVertexArrayVertexBuffer(vertex_array_object, 1, buffers[1], 0, sizeof(GLfloat) * 3); 
    glVertexArrayAttribFormat(vertex_array_object, 1, 3, GL_FLOAT, GL_FALSE, 0); 
    glVertexArrayAttribBinding(vertex_array_object, 1, 1); 
    glEnableVertexArrayAttrib(vertex_array_object, 1); 
    glBindVertexArray(vertex_array_object); 

    GLfloat clearcolor[4] = { 0.0,0.0,0.0,1.0 }; 
    glPointSize(40); 

    int width, height; 
    while (!glfwWindowShouldClose(window)) 
    { 
     glfwGetWindowSize(window, &width, &height); 
     glViewport(0, 0, width, height); 
     glClearBufferfv(GL_COLOR, 0, clearcolor); 

     for (int i = 0; i < 9; i++) { 
      color[i] = (rand() % 2); 
     } 
     glVertexAttrib3fv(1, color); 

     glDrawArrays(GL_TRIANGLES, 0, 3); 

     glfwSwapBuffers(window); 
     glfwPollEvents(); 
    } 

    glDeleteVertexArrays(1,&vertex_array_object); 
    glDeleteProgram(program); 

    glfwTerminate(); 
    return 0; 
} 

Answer 1

glNamedBufferStorage(buffers[1], sizeof(color), color, 0); 

Diese OpenGL sagt die Daten zu kopieren, die derzeit in der gegebenen Anordnung in der gegebenen buffer object gespeichert ist. Es erzeugt keine Verbindung zwischen color und den gespeicherten Pufferdaten. OpenGL kann nicht wissen, dass Sie color ändern, nachdem dieser Befehl verarbeitet wurde.

Und glVertexAttrib3fv tut nicht, was Sie denken, dass es ist.

Wenn Sie die Daten in einem OpenGL-Pufferobjekt ändern möchten, müssen Sie einen OpenGL-Aufruf durchführen, um andere Daten in den Puffer zu laden.

Außerdem haben Sie einen statischen Puffer erstellt (der Verwendungsparameter ist 0). Der springende Punkt eines statischen Puffers ist, dass es statisch ist: sein Inhalt wird zum Zeitpunkt seiner Erstellung festgelegt. So würde jeder der Upload-Befehle, wie glNamedBufferSubData nicht funktionieren.

Sie müssen also entscheiden, wie Sie die Daten des Puffers aktualisieren möchten. Möchten Sie es zuordnen und die Daten über den Zeiger ändern? Möchten Sie es persistent kartieren? Möchten Sie glNamedBufferSubData verwenden, um es zu aktualisieren? Möchten Sie den Puffer ungültig machen, bevor Sie ihn aktualisieren? Es gibt viele Strategien zum Aktualisieren von OpenGL-Pufferobjekten.

Das einfachste wäre und glNamedBufferSubData verwenden ungültig zu machen, aber Sie werden einen entsprechenden Verwendungsparameter dafür brauchen:

glNamedBufferStorage(buffers[1], sizeof(color), color, GL_DYNAMIC_STORAGE_BIT); 

...

while (!glfwWindowShouldClose(window)) 
{ 
    glfwGetWindowSize(window, &width, &height); 
    glViewport(0, 0, width, height); 
    glClearBufferfv(GL_COLOR, 0, clearcolor); 

    for (int i = 0; i < 9; i++) { 
     color[i] = (rand() % 2); 
    } 

    glInvalidateBufferData(buffer[1]); 
    glNamedBufferSubData(buffer[1], 0, sizeof(color), color); 

    glDrawArrays(GL_TRIANGLES, 0, 3); 

    glfwSwapBuffers(window); 
    glfwPollEvents(); 
}