Undo change to directly work on buffer. Causes about 30% slowdown...

2 files changed, 25 insertions, 21 deletions

diff --git a/BuddhaTest/Shaders/BuddhaCompute.glsl b/BuddhaTest/Shaders/BuddhaCompute.glsl
index 10ed77f..10dfe23 100644
--- a/BuddhaTest/Shaders/BuddhaCompute.glsl
+++ b/BuddhaTest/Shaders/BuddhaCompute.glsl
@@ -25,7 +25,7 @@ struct individualData
 
 layout(packed, binding=5) restrict buffer statusBuffer
 {
-    restrict individualData state[];
+    restrict individualData stateArray[];
 };
 
 uniform uint width;
@@ -211,59 +211,62 @@ void main() {
     const uint _totalIterations = orbitLength.x > orbitLength.y ? orbitLength.x : orbitLength.y;
     const uint totalIterations = _totalIterations > orbitLength.z ? _totalIterations : orbitLength.z;
 
+    individualData state = stateArray[uniqueWorkerID];
+
     //getIndividualState(in uint CellID, out vec2 offset, out vec2 coordinates, out uint phase, out uint orbitNumber, out uint doneIterations)
     uint iterationsLeftToDo = iterationsPerDispatch;
-    vec2 offset = getCurrentOrbitOffset(state[uniqueWorkerID].orbitNumber, totalWorkers, uniqueWorkerID);
+    vec2 offset = getCurrentOrbitOffset(state.orbitNumber, totalWorkers, uniqueWorkerID);
 
     while(iterationsLeftToDo != 0)
     {
-        if(state[uniqueWorkerID].phase == 0)
+        if(state.phase == 0)
         {
             //new orbit:
             //we know that iterationsLeftToDo is at least 1 by the while condition.
             --iterationsLeftToDo; //count this as 1 iteration.
-            offset = getCurrentOrbitOffset(state[uniqueWorkerID].orbitNumber, totalWorkers, uniqueWorkerID);
+            offset = getCurrentOrbitOffset(state.orbitNumber, totalWorkers, uniqueWorkerID);
             if(isInMainBulb(offset) || isInMainCardioid(offset))
             {
                 // do not waste time drawing this orbit
-                ++state[uniqueWorkerID].orbitNumber;
+                ++state.orbitNumber;
             }
             else
             {
                 //cool orbit!
-                state[uniqueWorkerID].lastPosition = vec2(0);
-                state[uniqueWorkerID].phase = 1;
-                state[uniqueWorkerID].doneIterations = 0;
+                state.lastPosition = vec2(0);
+                state.phase = 1;
+                state.doneIterations = 0;
             }
         }
-        if(state[uniqueWorkerID].phase == 1)
+        if(state.phase == 1)
         {
             //check if this orbit is going to be drawn
             bool result;
-            if(isGoingToBeDrawn(offset,totalIterations, state[uniqueWorkerID].lastPosition, iterationsLeftToDo, state[uniqueWorkerID].doneIterations , result))
+            if(isGoingToBeDrawn(offset,totalIterations, state.lastPosition, iterationsLeftToDo, state.doneIterations , result))
             {
                 if(result)
                 {
                     //on to step 2: drawing
-                    state[uniqueWorkerID].phase = 2;
-                    state[uniqueWorkerID].lastPosition = vec2(0);
-                    state[uniqueWorkerID].doneIterations = 0;
+                    state.phase = 2;
+                    state.lastPosition = vec2(0);
+                    state.doneIterations = 0;
                 }
                 else
                 {
                     //back to step 0
-                    ++state[uniqueWorkerID].orbitNumber;
-                    state[uniqueWorkerID].phase = 0;
+                    ++state.orbitNumber;
+                    state.phase = 0;
                 }
             }
         }
-        if(state[uniqueWorkerID].phase == 2)
+        if(state.phase == 2)
         {
-            if(drawOrbit(offset, totalIterations, state[uniqueWorkerID].lastPosition, iterationsLeftToDo, state[uniqueWorkerID].doneIterations))
+            if(drawOrbit(offset, totalIterations, state.lastPosition, iterationsLeftToDo, state.doneIterations))
             {
-                ++state[uniqueWorkerID].orbitNumber;
-                state[uniqueWorkerID].phase = 0;
+                ++state.orbitNumber;
+                state.phase = 0;
             }
         }
     }
+    stateArray[uniqueWorkerID] = state;
 }
diff --git a/BuddhaTest/src/BuddhaTest.cpp b/BuddhaTest/src/BuddhaTest.cpp
index 1a960cb..3b99169 100644
--- a/BuddhaTest/src/BuddhaTest.cpp
+++ b/BuddhaTest/src/BuddhaTest.cpp
@@ -132,10 +132,10 @@ int main(int argc, char * argv[])
     GLint bufferAlignment;
     GLenum t = GL_BUFFER_DATA_SIZE;
     glGetProgramResourceiv(ComputeShader,GL_SHADER_STORAGE_BLOCK,stateBufferIndex,1,&t,1,nullptr,&bufferAlignment);
-    GLuint stateStructIndex = glGetProgramResourceIndex(ComputeShader,GL_BUFFER_VARIABLE,"state[0].phase");
+    GLuint stateStructIndex = glGetProgramResourceIndex(ComputeShader,GL_BUFFER_VARIABLE,"stateArray[0].phase");
     GLint requiredStateBufferSizePerWorker;
     t = GL_TOP_LEVEL_ARRAY_STRIDE;
-    glGetProgramResourceiv(ComputeShader,GL_BUFFER_VARIABLE,stateBufferIndex,1,&t,1,nullptr,&requiredStateBufferSizePerWorker);
+    glGetProgramResourceiv(ComputeShader,GL_BUFFER_VARIABLE,stateStructIndex,1,&t,1,nullptr,&requiredStateBufferSizePerWorker);
 
     const uint32_t workersPerFrame = settings.globalWorkGroupSizeX*settings.globalWorkGroupSizeY*settings.globalWorkGroupSizeZ*settings.localWorkgroupSizeX*settings.localWorkgroupSizeY*settings.localWorkgroupSizeZ;
     auto requiredStateMemory = ((requiredStateBufferSizePerWorker*workersPerFrame + bufferAlignment -1)/bufferAlignment) * bufferAlignment;
@@ -228,6 +228,7 @@ int main(int argc, char * argv[])
         }
     }
 
+    //settings.pngFilename = "Don'tForgetToRemoveThisLine.png";
     if(!settings.pngFilename.empty())
     {
         glMemoryBarrier(GL_ALL_BARRIER_BITS);