Verwenden Sie SSBO als VBO-Eingang für den nächsten Zeichenaufruf

Question

Ich schreibe einige Eckendaten innerhalb eines Shaders zu SSBO. Dann möchte ich die Daten verwenden, die als VBOs an den SSBO geschrieben wurden. Diese werden für den nächsten Zeichnungsaufruf verwendet. Wie kann das gemacht werden?

Hier ist, wie ich es jetzt tun, aber es Segfaults noch:

int new_vertex_count = …; 
int new_index_count = …; 
int* new_indices = …; 

GLuint ssbo[3]; 
glGenBuffers(3, ssbo); 


glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo[1]); 
glBufferData(GL_SHADER_STORAGE_BUFFER, new_vertex_count * 3 * sizeof(float), nullptr, GL_DYNAMIC_DRAW); 
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, ssbo[1]); 

glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo[2]); 
glBufferData(GL_SHADER_STORAGE_BUFFER, new_vertex_count * 2 * sizeof(float), nullptr, GL_DYNAMIC_DRAW); 
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo[2]); 

glBindVertexArray(vao); //bind the original VAO 
glPatchParameteri(GL_PATCH_VERTICES, 16); 
glEnable(GL_RASTERIZER_DISCARD); //disable displaying 
glDrawElements(GL_PATCHES, index_count, GL_UNSIGNED_INT, 0); //don't draw, just 
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT); //sync writing 
glFinish(); 
glDisable(GL_RASTERIZER_DISCARD); //reanable displaying for next draw call 
glBindVertexArray(0); //unbind original VAO in order to use new VBOs 


glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ssbo[0]); 
glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_count * sizeof(uint), indices, GL_STATIC_DRAW); 

glBindBuffer(GL_ARRAY_BUFFER, ssbo[1]); //bind SSBO as VBO, is this even possible? 
//or should I use new VBOs and copy? How would I copy then? 
glEnableVertexAttribArray(0); 
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); 

glBindBuffer(GL_ARRAY_BUFFER, ssbo[2]); 
glEnableVertexAttribArray(1); 
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0); 

glDrawElements(GL_PATCHES, new_index_count, new_indices, GL_UNSIGNED_INT, 0); //here the real drawing 

Answer 1

Es gibt nicht so etwas wie eine „SSBO“ oder einen „VBO“. Es gibt nur Pufferobjekte. Speicherblöcke und Vertexarrays werden für Pufferobjekte verwendet, aber ein bestimmter Puffer ist nicht inhärent mit einer bestimmten Verwendung verknüpft. Es gibt nichts, was Sie daran hindert, über einen Speicherblock in einen Puffer zu schreiben und dann in einem Rendervorgang davon zu lesen.

Solange Sie die Regeln von incoherent memory access für diese schreiben, natürlich. Schreibvorgänge über einen Speicherblock sind für Lesevorgänge nicht verfügbar, es sei denn, Sie stellen sie explizit zur Verfügung. Sie würden dafür glMemoryBarrier verwenden. Und die Art und Weise eine memory barrier works ist, dass der Enumerator die Operationen angibt, die Sie in der Lage sein, die Ergebnisse von zu sehen, was auch immer geschrieben wurde.

Sie möchten, dass die geschriebenen Daten als Vertex-Attribut-Arrays gelesen werden. So verwenden Sie:

glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT​);