Changeset 996dd3e in opengl-game

Timestamp:

May 14, 2021, 1:09:34 AM (4 years ago)

Author:

Dmitry Portnoy <dportnoy@…>

Branches:

feature/imgui-sdl

Children:

a3cefaa

Parents:

9d21aac

Message:

Completely remove storage buffers from the GraphicsPipeline_Vulkan class and start moving storage buffer operations out of the addObject() and updateObject() functions

Files:

• graphics-pipeline_vulkan.hpp (modified) (2 diffs)
• sdl-game.cpp (modified) (8 diffs)
• sdl-game.hpp (modified) (7 diffs)
• vulkan-game.cpp (modified) (23 diffs)
• vulkan-game.hpp (modified) (7 diffs)
• vulkan-utils.hpp (modified) (2 diffs)

graphics-pipeline_vulkan.hpp

@@ -22 +22 @@
 using namespace glm;
 
-// TODO: Use this struct for uniform buffers as well and rename it to VulkanBuffer (maybe move it to VulkanUtils)
-// Also, probably better to make this a vector of structs where each struct
-// has a VkBuffer, VkDeviceMemory, and VkDescriptorBufferInfo
-struct StorageBufferSet {
-   vector<VkBuffer> buffers;
-   vector<VkDeviceMemory> memory;
-   vector<VkDescriptorBufferInfo> infoSet;
-};
-
 // TODO: Maybe change the name of this struct so I can call the list something other than descriptorInfoList
 struct DescriptorInfo {
@@ -45 +36 @@
    public:
       string vertShaderFile, fragShaderFile;
-
-      // TODO: Move this outside this classs, since it is no longer used here
-      StorageBufferSet storageBufferSet;
 
       // Both of these are only used for managing the SSBO, so move them out as well

sdl-game.cpp

@@ -110 +110 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_modelPipeline);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &modelPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_modelPipeline.infoSet);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
       VK_SHADER_STAGE_FRAGMENT_BIT, &floorTextureImageDescriptor);
@@ -131 +131 @@
       }, {
          mat4(1.0f)
-      }, false);
+      }, storageBuffers_modelPipeline, false);
+
+   updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare->ssbo);
 
    texturedSquare->model_base =
@@ -150 +152 @@
       }, {
          mat4(1.0f)
-      }, false);
+      }, storageBuffers_modelPipeline, false);
+
+   updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare->ssbo);
 
    texturedSquare->model_base =
@@ -264 +268 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      modelPipeline.storageBufferSet.buffers, modelPipeline.storageBufferSet.memory,
-      modelPipeline.storageBufferSet.infoSet);
+      storageBuffers_modelPipeline.buffers, storageBuffers_modelPipeline.memory,
+      storageBuffers_modelPipeline.infoSet);
 }
 
@@ -372 +376 @@
                         }, {
                            mat4(1.0f)
-                        }, true);
+                        }, storageBuffers_modelPipeline, true);
+
+                  updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare.ssbo);
 
                   texturedSquare.model_base =
@@ -439 +445 @@
 }
 
-// TODO: The only updates that need to happen once per Vulkan image are the SSBO ones,
-// which are already handled by updateObject(). Move this code to a different place,
-// where it will run just once per frame
 void VulkanGame::updateScene() {
+   // TODO: These two for loops could probably be combined into one
+
    for (SceneObject<ModelVertex, SSBO_ModelObject>& model : this->modelObjects) {
       model.model_transform =
@@ -450 +455 @@
    }
 
+   // TODO: Instead, update entire sections (up to 64k) of the dynamic ubo if some objects there have changed
+   // Also, update the objects modelMat and center in the loop above instead of here
    for (size_t i = 0; i < modelObjects.size(); i++) {
       if (modelObjects[i].modified) {
+         // TODO: Think about changing the SSBO-related code to also use a contiguous array
+         // to store the data on the cpu side instead of storing it per-object
+         // Then, I could also copy it to the GPU in one go
+         // Also, double-check if the alignment restrictions also hold for SSBOs
+
          updateObject(modelObjects, modelPipeline, i);
+         updateStorageBuffer(storageBuffers_modelPipeline, i, modelObjects[i].ssbo);
       }
    }
@@ -475 +488 @@
    modelPipeline.cleanupBuffers();
 
-   for (size_t i = 0; i < modelPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, modelPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, modelPipeline.storageBufferSet.memory[i], nullptr);
+   for (size_t i = 0; i < storageBuffers_modelPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_modelPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_modelPipeline.memory[i], nullptr);
    }
 

sdl-game.hpp

@@ -72 +72 @@
    alignas(16) mat4 view;
    alignas(16) mat4 proj;
+};
+
+// TODO: Use this struct for uniform buffers as well and probably combine it with the VulkanBuffer class
+// Also, probably better to make this a vector of structs where each struct
+// has a VkBuffer, VkDeviceMemory, and VkDescriptorBufferInfo
+struct StorageBufferSet {
+   vector<VkBuffer> buffers;
+   vector<VkDeviceMemory> memory;
+   vector<VkDescriptorBufferInfo> infoSet;
 };
 
@@ -208 +217 @@
       // wouldn't work since the whole pipeline couldn't have a common set of descriptors for the textures
       GraphicsPipeline_Vulkan<ModelVertex> modelPipeline;
+
+      StorageBufferSet storageBuffers_modelPipeline;
 
       // TODO: Maybe make the ubo objects part of the pipeline class since there's only one ubo
@@ -297 +308 @@
                                                    GraphicsPipeline_Vulkan<VertexType>& pipeline,
                                                    const vector<VertexType>& vertices, vector<uint16_t> indices,
-                                                   SSBOType ssbo, bool pipelinesCreated);
+                                                   SSBOType ssbo, StorageBufferSet& storageBuffers,
+                                                   bool pipelinesCreated);
 
       template<class VertexType>
@@ -381 +393 @@
                                                          GraphicsPipeline_Vulkan<VertexType>& pipeline,
                                                          const vector<VertexType>& vertices, vector<uint16_t> indices,
-                                                         SSBOType ssbo, bool pipelinesCreated) {
+                                                         SSBOType ssbo, StorageBufferSet& storageBuffers,
+                                                         bool pipelinesCreated) {
    // TODO: Use the model field of ssbo to set the object's model_base
    // currently, the passed in model is useless since it gets overridden in updateObject() anyway
@@ -403 +416 @@
    pipeline.addObject(obj.vertices, obj.indices, resourceCommandPool, graphicsQueue);
 
+   // TODO: Probably move the resizing to the VulkanBuffer class
+   // First, try moving this out of addObject
    bool resizeStorageBuffer = pipeline.numObjects == pipeline.objectCapacity;
 
    if (resizeStorageBuffer) {
-      resizeStorageBufferSet<VertexType, SSBOType>(pipeline.storageBufferSet, resourceCommandPool, graphicsQueue, pipeline);
+      resizeStorageBufferSet<VertexType, SSBOType>(storageBuffers, resourceCommandPool, graphicsQueue, pipeline);
       pipeline.cleanup();
 
       // Assume the SSBO is always the 2nd binding
-      pipeline.updateDescriptorInfo(1, &pipeline.storageBufferSet.infoSet);
+      // TODO: Figure out a way to make this more flexible
+      pipeline.updateDescriptorInfo(1, &storageBuffers.infoSet);
    }
 
    pipeline.numObjects++;
-
-   updateStorageBuffer(pipeline.storageBufferSet, pipeline.numObjects - 1, obj.ssbo);
 
    // TODO: Figure out why I am destroying and recreating the ubos when the swap chain is recreated,
@@ -421 +435 @@
 
    if (pipelinesCreated) {
+      // TODO: See if I can avoid doing this when recreating the pipeline
       vkDeviceWaitIdle(device);
 
@@ -531 +546 @@
    obj.center = vec3(obj.ssbo.model * vec4(0.0f, 0.0f, 0.0f, 1.0f));
 
-   updateStorageBuffer(pipeline.storageBufferSet, index, obj.ssbo);
-
    obj.modified = false;
 }

vulkan-game.cpp

@@ -126 +126 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_modelPipeline);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &modelPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_modelPipeline.infoSet);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
       VK_SHADER_STAGE_FRAGMENT_BIT, &floorTextureImageDescriptor);
@@ -145 +145 @@
          }, {
             mat4(1.0f)
-         }, false);
+         }, storageBuffers_modelPipeline, false);
+
+   updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare->ssbo);
 
    texturedSquare->model_base =
@@ -164 +166 @@
          }, {
             mat4(1.0f)
-         }, false);
+         }, storageBuffers_modelPipeline, false);
+
+   updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare->ssbo);
 
    texturedSquare->model_base =
@@ -189 +193 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_shipPipeline);
    shipPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &shipPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_shipPipeline.infoSet);
 
    // TODO: With the normals, indexing basically becomes pointless since no vertices will have exactly
@@ -424 +428 @@
       }, {
          mat4(1.0f)
-      }, false);
+      }, storageBuffers_shipPipeline, false);
+
+   updateStorageBuffer(storageBuffers_shipPipeline, shipPipeline.numObjects - 1, ship.ssbo);
 
    ship.model_base =
@@ -449 +455 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_asteroidPipeline);
    asteroidPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &asteroidPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_asteroidPipeline.infoSet);
 
    asteroidPipeline.createDescriptorSetLayout();
@@ -467 +473 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_laserPipeline);
    laserPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, &laserPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, &storageBuffers_laserPipeline.infoSet);
    laserPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
       VK_SHADER_STAGE_FRAGMENT_BIT, &laserTextureImageDescriptor);
@@ -487 +493 @@
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_explosionPipeline);
    explosionPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &explosionPipeline.storageBufferSet.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_explosionPipeline.infoSet);
 
    explosionPipeline.createDescriptorSetLayout();
@@ -599 +605 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      modelPipeline.storageBufferSet.buffers, modelPipeline.storageBufferSet.memory,
-      modelPipeline.storageBufferSet.infoSet);
+      storageBuffers_modelPipeline.buffers, storageBuffers_modelPipeline.memory,
+      storageBuffers_modelPipeline.infoSet);
 
    shipPipeline = GraphicsPipeline_Vulkan<ModelVertex>(
@@ -609 +615 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      shipPipeline.storageBufferSet.buffers, shipPipeline.storageBufferSet.memory,
-      shipPipeline.storageBufferSet.infoSet);
+      storageBuffers_shipPipeline.buffers, storageBuffers_shipPipeline.memory,
+      storageBuffers_shipPipeline.infoSet);
 
    asteroidPipeline = GraphicsPipeline_Vulkan<ModelVertex>(
@@ -619 +625 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      asteroidPipeline.storageBufferSet.buffers, asteroidPipeline.storageBufferSet.memory,
-      asteroidPipeline.storageBufferSet.infoSet);
+      storageBuffers_asteroidPipeline.buffers, storageBuffers_asteroidPipeline.memory,
+      storageBuffers_asteroidPipeline.infoSet);
 
    laserPipeline = GraphicsPipeline_Vulkan<LaserVertex>(
@@ -629 +635 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      laserPipeline.storageBufferSet.buffers, laserPipeline.storageBufferSet.memory,
-      laserPipeline.storageBufferSet.infoSet);
+      storageBuffers_laserPipeline.buffers, storageBuffers_laserPipeline.memory,
+      storageBuffers_laserPipeline.infoSet);
 
    explosionPipeline = GraphicsPipeline_Vulkan<ExplosionVertex>(
@@ -640 +646 @@
       VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-      explosionPipeline.storageBufferSet.buffers, explosionPipeline.storageBufferSet.memory,
-      explosionPipeline.storageBufferSet.infoSet);
+      storageBuffers_explosionPipeline.buffers, storageBuffers_explosionPipeline.memory,
+      storageBuffers_explosionPipeline.infoSet);
 }
 
@@ -762 +768 @@
                            }, {
                               mat4(1.0f)
-                           }, true);
+                           }, storageBuffers_modelPipeline, true);
+
+                  updateStorageBuffer(storageBuffers_modelPipeline, modelPipeline.numObjects - 1, texturedSquare.ssbo);
 
                   texturedSquare.model_base =
@@ -1042 +1050 @@
                   10.0f,
                   false
-               }, true);
+               }, storageBuffers_asteroidPipeline, true);
+
+      updateStorageBuffer(storageBuffers_asteroidPipeline, asteroidPipeline.numObjects - 1, asteroid.ssbo);
 
       // This accounts for the scaling in model_base.
@@ -1070 +1080 @@
       if (shipObjects[i].modified) {
          updateObject(shipObjects, shipPipeline, i);
+         updateStorageBuffer(storageBuffers_shipPipeline, i, shipObjects[i].ssbo);
       }
    }
@@ -1076 +1087 @@
       if (modelObjects[i].modified) {
          updateObject(modelObjects, modelPipeline, i);
+         updateStorageBuffer(storageBuffers_modelPipeline, i, modelObjects[i].ssbo);
       }
    }
@@ -1082 +1094 @@
       if (asteroidObjects[i].modified) {
          updateObject(asteroidObjects, asteroidPipeline, i);
+         updateStorageBuffer(storageBuffers_asteroidPipeline, i, asteroidObjects[i].ssbo);
       }
    }
@@ -1088 +1101 @@
       if (laserObjects[i].modified) {
          updateObject(laserObjects, laserPipeline, i);
+         updateStorageBuffer(storageBuffers_laserPipeline, i, laserObjects[i].ssbo);
       }
    }
@@ -1094 +1108 @@
       if (explosionObjects[i].modified) {
          updateObject(explosionObjects, explosionPipeline, i);
+         updateStorageBuffer(storageBuffers_explosionPipeline, i, explosionObjects[i].ssbo);
       }
    }
@@ -1131 +1146 @@
    explosionPipeline.cleanupBuffers();
 
-   for (size_t i = 0; i < modelPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, modelPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, modelPipeline.storageBufferSet.memory[i], nullptr);
-   }
-
-   for (size_t i = 0; i < shipPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, shipPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, shipPipeline.storageBufferSet.memory[i], nullptr);
-   }
-
-   for (size_t i = 0; i < asteroidPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, asteroidPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, asteroidPipeline.storageBufferSet.memory[i], nullptr);
-   }
-
-   for (size_t i = 0; i < laserPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, laserPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, laserPipeline.storageBufferSet.memory[i], nullptr);
-   }
-
-   for (size_t i = 0; i < explosionPipeline.storageBufferSet.buffers.size(); i++) {
-      vkDestroyBuffer(device, explosionPipeline.storageBufferSet.buffers[i], nullptr);
-      vkFreeMemory(device, explosionPipeline.storageBufferSet.memory[i], nullptr);
+   for (size_t i = 0; i < storageBuffers_modelPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_modelPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_modelPipeline.memory[i], nullptr);
+   }
+
+   for (size_t i = 0; i < storageBuffers_shipPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_shipPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_shipPipeline.memory[i], nullptr);
+   }
+
+   for (size_t i = 0; i < storageBuffers_asteroidPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_asteroidPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_asteroidPipeline.memory[i], nullptr);
+   }
+
+   for (size_t i = 0; i < storageBuffers_laserPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_laserPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_laserPipeline.memory[i], nullptr);
+   }
+
+   for (size_t i = 0; i < storageBuffers_explosionPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, storageBuffers_explosionPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, storageBuffers_explosionPipeline.memory[i], nullptr);
    }
 
@@ -1914 +1929 @@
          color,
          false
-      }, true);
+      }, storageBuffers_laserPipeline, true);
+
+   updateStorageBuffer(storageBuffers_laserPipeline, laserPipeline.numObjects - 1, laser.ssbo);
 
    float xAxisRotation = asin(ray.y / length);
@@ -2124 +2141 @@
          duration,
          false
-      }, true);
+      }, storageBuffers_explosionPipeline, true);
+
+   updateStorageBuffer(storageBuffers_explosionPipeline, explosionPipeline.numObjects - 1, explosion.ssbo);
 
    explosion.model_base = model_mat;

vulkan-game.hpp

@@ -96 +96 @@
    alignas(16) mat4 proj;
    alignas(4) float cur_time;
+};
+
+// TODO: Use this struct for uniform buffers as well and probably combine it with the VulkanBuffer class
+// Also, probably better to make this a vector of structs where each struct
+// has a VkBuffer, VkDeviceMemory, and VkDescriptorBufferInfo
+struct StorageBufferSet {
+   vector<VkBuffer> buffers;
+   vector<VkDeviceMemory> memory;
+   vector<VkDescriptorBufferInfo> infoSet;
 };
 
@@ -305 +314 @@
       GraphicsPipeline_Vulkan<LaserVertex> laserPipeline;
       GraphicsPipeline_Vulkan<ExplosionVertex> explosionPipeline;
+
+      StorageBufferSet storageBuffers_modelPipeline;
+      StorageBufferSet storageBuffers_shipPipeline;
+      StorageBufferSet storageBuffers_asteroidPipeline;
+      StorageBufferSet storageBuffers_laserPipeline;
+      StorageBufferSet storageBuffers_explosionPipeline;
 
       // TODO: Maybe make the ubo objects part of the pipeline class since there's only one ubo
@@ -440 +455 @@
                                                    GraphicsPipeline_Vulkan<VertexType>& pipeline,
                                                    const vector<VertexType>& vertices, vector<uint16_t> indices,
-                                                   SSBOType ssbo, bool pipelinesCreated);
+                                                   SSBOType ssbo, StorageBufferSet& storageBuffers,
+                                                   bool pipelinesCreated);
 
       template<class VertexType>
@@ -544 +560 @@
                                                          GraphicsPipeline_Vulkan<VertexType>& pipeline,
                                                          const vector<VertexType>& vertices, vector<uint16_t> indices,
-                                                         SSBOType ssbo, bool pipelinesCreated) {
+                                                         SSBOType ssbo, StorageBufferSet& storageBuffers,
+                                                         bool pipelinesCreated) {
    // TODO: Use the model field of ssbo to set the object's model_base
    // currently, the passed in model is useless since it gets overridden in updateObject() anyway
@@ -566 +583 @@
    pipeline.addObject(obj.vertices, obj.indices, resourceCommandPool, graphicsQueue);
 
+   // TODO: Probably move the resizing to the VulkanBuffer class
+   // First, try moving this out of addObject
    bool resizeStorageBuffer = pipeline.numObjects == pipeline.objectCapacity;
 
    if (resizeStorageBuffer) {
-      resizeStorageBufferSet<VertexType, SSBOType>(pipeline.storageBufferSet, resourceCommandPool, graphicsQueue, pipeline);
+      resizeStorageBufferSet<VertexType, SSBOType>(storageBuffers, resourceCommandPool, graphicsQueue, pipeline);
       pipeline.cleanup();
 
       // Assume the SSBO is always the 2nd binding
-      pipeline.updateDescriptorInfo(1, &pipeline.storageBufferSet.infoSet);
+      // TODO: Figure out a way to make this more flexible
+      pipeline.updateDescriptorInfo(1, &storageBuffers.infoSet);
    }
 
    pipeline.numObjects++;
-
-   updateStorageBuffer(pipeline.storageBufferSet, pipeline.numObjects - 1, obj.ssbo);
 
    // TODO: Figure out why I am destroying and recreating the ubos when the swap chain is recreated,
@@ -584 +602 @@
 
    if (pipelinesCreated) {
+      // TODO: See if I can avoid doing this when recreating the pipeline
       vkDeviceWaitIdle(device);
 
@@ -699 +718 @@
    obj.center = vec3(obj.ssbo.model * vec4(0.0f, 0.0f, 0.0f, 1.0f));
 
-   updateStorageBuffer(pipeline.storageBufferSet, index, obj.ssbo);
-
    obj.modified = false;
 }

vulkan-utils.hpp

@@ -117 +117 @@
 template<class DataType>
 void VulkanUtils::copyDataToBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
-      const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset, VkQueue graphicsQueue) {
+                                   const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset,
+                                   VkQueue graphicsQueue) {
    VkDeviceSize srcDataSize = srcData.size() * sizeof(DataType);
 
@@ -140 +141 @@
 template<class DataType>
 void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
-   VkDeviceSize offset) {
+                                   VkDeviceSize offset) {
    copyDataToMemory(device, srcData, bufferMemory, offset, sizeof(DataType));
 }
 
+// TODO: This would be used when the GPU memory is host-coherent. If it it not, I also need to use vkFlushMappedMemoryRanges
+// I should create a variant that supports non-coherent memory
 template<class DataType>
 void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,