Merge branch 'append-vertices' into patchRender

QTProject/resources.qrc

@@ -5,6 +5,7 @@
         <file>subdivide.tcs</file>
         <file>subdivide.tes</file>
         <file>subdivide.vert</file>
+        <file>subdivision-copy.compute</file>
         <file>subdivision-edge.compute</file>
         <file>subdivision-vertex.compute</file>
         <file>subdivideRegular.tcs</file>

QTProject/subdivision-copy.compute

+#version 430 core
+
+layout  (local_size_x  =  1)  in;
+
+struct Vertex {
+    vec3 pos;
+    vec3 norm;
+    vec2 uv;
+};
+
+layout(std430, binding=0) readonly buffer Input {
+    Vertex vertices_in[];
+};
+
+layout(std430, binding=1) writeonly buffer Output {
+    Vertex vertices_out[];
+};
+
+void main(){
+    vertices_out[gl_GlobalInvocationID.x] = vertices_in[gl_GlobalInvocationID.x];
+}

QTProject/subdivision.cpp

@@ -10,6 +10,7 @@ Subdivision::Subdivision(QOpenGLFunctions_4_3_Core *f)
 
 Subdivision::~Subdivision()
 {
+    delete copyShader;
     delete edgeShader;
     delete vertexShader;
 }
@@ -21,7 +22,10 @@ QString Subdivision::formatTimeMeasurement(int time){
 }
 
 void Subdivision::init() {
-    QString source = QLatin1String(":/subdivision-edge.compute");
+    QString source = QLatin1String(":/subdivision-copy.compute");
+    copyShader = initComputeShaderProgram(source);
+
+    source = QLatin1String(":/subdivision-edge.compute");
     edgeShader = initComputeShaderProgram(source);
 
     source = QLatin1String(":/subdivision-vertex.compute");
@@ -172,11 +176,15 @@ Subdivision::Tables Subdivision::precomputeTables(Input input) {
     precomputeEdgeTable(tables, triangles, triangles_regular, (unsigned int) vb.length());
     qCDebug(log_timing) << "precomputeEdgeTable:" << formatTimeMeasurement(subTimer.elapsed());
 
+    QMap<unsigned int, unsigned int> modified_vertices;
     subTimer.restart();
-    precomputeVertexTable(tables, input);
+    precomputeVertexTable(tables, input, modified_vertices);
     qCDebug(log_timing) << "precomputeVertexTable:" << formatTimeMeasurement(subTimer.elapsed());
 
-    //tables.patch_index_regular = getPatchIndexBuffer(ib, QVector<unsigned int>());//TODO pass regular and irregular index buffer?
+    subTimer.restart();
+    updateIndexBuffer(tables.index_buffer, modified_vertices);
+    qCDebug(log_timing) << "updateIndexBuffer:" << formatTimeMeasurement(subTimer.elapsed());
+
     qCDebug(log_subdiv) << "Precompute Tables Done";
     return tables;
 }
@@ -303,18 +311,20 @@ void Subdivision::precomputeEdgeTable(Subdivision::Tables &tables, QVector<Trian
     }
 }
 
-void Subdivision::precomputeVertexTable(Subdivision::Tables &tables, Input &input) {
+void Subdivision::precomputeVertexTable(Subdivision::Tables &tables, Input &input, QMap<unsigned int, unsigned int> &modified_vertices) {
     //compute vertex table
     //Format: First entry: original vertex. Other entries: adjacent vertices.
     QVector<QVector<unsigned int> > duplicates;//for debugging
     QVector<unsigned int> ib_combined = input.index_irregular_buffer + input.index_regular_buffer;
     unsigned int offset = 0;
+    unsigned int output_offset = input.vertex_buffer.size() + tables.edge_indices.size() / 4;
     for (int i = 0; i < input.vertex_buffer.length(); i++){
         //hat evtl viel redundanz
 
         QVector<Vertex> adj_v;//helfer
         tables.vertex_offsets.push_back(offset);
         tables.vertex_indices.push_back(i);
+        modified_vertices.insert(i, output_offset + i);
         offset++;
 
         Vertex originalVertex = input.vertex_buffer[i];
@@ -378,6 +388,13 @@ void Subdivision::precomputeVertexTable(Subdivision::Tables &tables, Input &inpu
     }
 }
 
+void Subdivision::updateIndexBuffer(QVector<unsigned int> &index_buffer, QMap<unsigned int, unsigned int> map) {
+    for (int i = 0; i < index_buffer.length(); i++) {
+        unsigned int old = index_buffer[i];
+        index_buffer[i] = map.value(old, old);
+    }
+}
+
 void Subdivision::splitRegular(Mesh *mesh) {
     QTime totalTimer;
     totalTimer.start();
@@ -711,38 +728,36 @@ Subdivision::Result Subdivision::runShader(Input input, Tables &tables) {
     f->glBufferData(GL_SHADER_STORAGE_BUFFER, tables.edge_indices.size() * sizeof(GLuint), tables.edge_indices.data(), GL_DYNAMIC_DRAW);
 
     // Create an output buffer
+    // the new vertex buffer contains the old vertices + the new edge vertices + the modified non-edge vertices
+    unsigned int output_size = input.vertex_buffer.size() + tables.edge_indices.size() / 4 + (tables.vertex_offsets.size() - 1);
     GLuint output_handle;
     f->glGenBuffers(1, &output_handle);
     f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, output_handle);
-    f->glBufferData(GL_SHADER_STORAGE_BUFFER, (input.vertex_buffer.size() + tables.edge_indices.size() / 4) * sizeof(Vertex), NULL, GL_DYNAMIC_DRAW);
+    f->glBufferData(GL_SHADER_STORAGE_BUFFER, output_size * sizeof(Vertex), NULL, GL_DYNAMIC_DRAW);
     result.vb_handle = output_handle;
 
     f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
     QTime timer;
     timer.start();
-    runVertexShader(input.vertex_buffer.size(), input.vb_handle, vertex_indices_handle, vertex_offsets_handle, output_handle);
-    int vertexTime = timer.elapsed();
+    runCopyShader(input.vertex_buffer.size(), input.vb_handle, output_handle);
+    int copyTime = timer.elapsed();
     timer.restart();
-    int edgeOffset = input.vertex_buffer.size();
-    runEdgeShader(tables.edge_indices.size() / 4, input.vb_handle, edge_indices_handle, output_handle, edgeOffset);
+    int edge_offset = input.vertex_buffer.size();
+    runEdgeShader(tables.edge_indices.size() / 4, input.vb_handle, edge_indices_handle, output_handle, edge_offset);
     int edgeTime = timer.elapsed();
     timer.restart();
+    int vertex_offset = edge_offset + tables.edge_indices.size() / 4;
+    runVertexShader(input.vertex_buffer.size(), input.vb_handle, vertex_indices_handle, vertex_offsets_handle, output_handle, vertex_offset);
+    int vertexTime = timer.elapsed();
 
+    timer.restart();
     // Map the output buffer so we can read the results
     f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, output_handle);
     Vertex *ptr;
     ptr = (Vertex *) f->glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_WRITE_ONLY);
-
-    qCDebug(log_subdiv_trace) << "New vertices:";
-    for (int i = 0; i < input.vertex_buffer.size(); i++) {
-        qCDebug(log_subdiv_trace) << ptr[i].pos;
+    for (unsigned int i = 0; i < output_size; i++) {
         result.vertex_buffer.push_back(ptr[i]);
     }
-    qCDebug(log_subdiv_trace) << "New edge points:";
-    for (int i = 0; i < tables.edge_indices.size() / 4; i++) {
-        qCDebug(log_subdiv_trace) << ptr[edgeOffset + i].pos;
-        result.vertex_buffer.push_back(ptr[edgeOffset + i]);
-    }
     int bufferbildTime = timer.elapsed();
 
     f->glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
@@ -752,17 +767,36 @@ Subdivision::Result Subdivision::runShader(Input input, Tables &tables) {
     f->glDeleteBuffers(1, &vertex_offsets_handle);
     f->glDeleteBuffers(1, &edge_indices_handle);
 
-    qCDebug(log_timing)<<"Compute Shader done. Vertexshader"<<vertexTime<<"ms; EdgeShader"<<edgeTime<<" BufferToCPU"<<bufferbildTime<<"ms";
+    qCDebug(log_timing)<<"Compute Shader done. Copyshader"<<copyTime<<"ms; Vertexshader"<<vertexTime<<"ms; EdgeShader"<<edgeTime<<" BufferToCPU"<<bufferbildTime<<"ms";
     return result;
 }
 
-void Subdivision::runVertexShader(GLuint size, GLuint vb_handle, GLuint vertex_indices_handle, GLuint vertex_offsets_handle, GLuint output_handle) {
+void Subdivision::runCopyShader(GLuint size, GLuint vb_in, GLuint vb_out) {
+    copyShader->bind();
+
+    f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, vb_in);
+    f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, vb_out);
+
+    // Run the shader
+    f->glDispatchCompute(size, 1, 1);
+
+    // Wait for the shader to complete and the data to be written back to the global memory
+    f->glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+
+    // Unbind the buffers from the shader
+    f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0);
+    f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, 0);
+
+    copyShader->release();
+}
+
+void Subdivision::runVertexShader(GLuint size, GLuint vb_handle, GLuint vertex_indices_handle, GLuint vertex_offsets_handle, GLuint output_handle, GLuint offset) {
     vertexShader->bind();
 
     f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, vb_handle);
     f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, vertex_indices_handle);
     f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, vertex_offsets_handle);
-    f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, output_handle);
+    f->glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 3, output_handle, offset * sizeof(Vertex), size * sizeof(Vertex));
 
     // Run the shader
     f->glDispatchCompute(size, 1, 1);

QTProject/subdivision.h

@@ -51,16 +51,19 @@ private:
     QString formatTimeMeasurement(int time);
 
     QOpenGLFunctions_4_3_Core *f;
+    QOpenGLShaderProgram *copyShader;
     QOpenGLShaderProgram *edgeShader;
     QOpenGLShaderProgram *vertexShader;
 
     QOpenGLShaderProgram *initComputeShaderProgram(QString &source);
     Tables precomputeTables(Input input);
     void precomputeEdgeTable(Subdivision::Tables &tables, QVector<Triangle> &triangles, QVector<Triangle> &triangles_regular, unsigned int offset);
-    void precomputeVertexTable(Subdivision::Tables &tables, Input &input);
+    void precomputeVertexTable(Subdivision::Tables &tables, Input &input, QMap<unsigned int, unsigned int> &modified_vertices);
+    void updateIndexBuffer(QVector<unsigned int> &index_buffer, QMap<unsigned int, unsigned int> map);
     void findRegular(QVector<unsigned int> index_buffer, QVector<Vertex> vertex_buffer, QVector<unsigned int> &regular, QVector<unsigned int> &irregular);
     Result runShader(Input input, Tables &tables);
-    void runVertexShader(GLuint size, GLuint vb_handle, GLuint vertex_indices_handle, GLuint vertex_offsets_handle, GLuint output_handle);
+    void runCopyShader(GLuint size, GLuint vb_in, GLuint vb_out);
+    void runVertexShader(GLuint size, GLuint vb_handle, GLuint vertex_indices_handle, GLuint vertex_offsets_handle, GLuint output_handle, GLuint offset);
     void runEdgeShader(GLuint size, GLuint vb_handle, GLuint edge_indices_handle, GLuint output_handle, GLuint offset);
 
     QVector<unsigned int> patchIBToTriangleIB(QVector<unsigned int> ib);