Index: vulkan-game.cpp
===================================================================
--- vulkan-game.cpp	(revision 2f4ff8c378d4f7cbab4858c6a7dca849b7f57882)
+++ vulkan-game.cpp	(revision b01b50c40d6cfb28d8e12f40f6f76c71dce70a0e)
@@ -168,12 +168,12 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_modelPipeline);
-
-   objects_modelPipeline.map(storageBuffers_modelPipeline.memory, device);
+                   objectBuffers_modelPipeline);
+
+   objects_modelPipeline.map(objectBuffers_modelPipeline.memory, device);
 
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBuffers_modelPipeline.infoSet);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_modelPipeline.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &objectBuffers_modelPipeline.infoSet);
    modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
       VK_SHADER_STAGE_FRAGMENT_BIT, &floorTextureImageDescriptor);
@@ -242,12 +242,12 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_shipPipeline);
-
-   objects_shipPipeline.map(storageBuffers_shipPipeline.memory, device);
+                   objectBuffers_shipPipeline);
+
+   objects_shipPipeline.map(objectBuffers_shipPipeline.memory, device);
 
    shipPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBuffers_shipPipeline.infoSet);
    shipPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_shipPipeline.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &objectBuffers_shipPipeline.infoSet);
 
    // TODO: With the normals, indexing basically becomes pointless since no vertices will have exactly
@@ -513,12 +513,12 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_asteroidPipeline);
-
-   objects_asteroidPipeline.map(storageBuffers_asteroidPipeline.memory, device);
+                   objectBuffers_asteroidPipeline);
+
+   objects_asteroidPipeline.map(objectBuffers_asteroidPipeline.memory, device);
 
    asteroidPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBuffers_asteroidPipeline.infoSet);
    asteroidPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_asteroidPipeline.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &objectBuffers_asteroidPipeline.infoSet);
 
    asteroidPipeline.createDescriptorSetLayout();
@@ -542,12 +542,12 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_laserPipeline);
-
-   objects_laserPipeline.map(storageBuffers_laserPipeline.memory, device);
+                   objectBuffers_laserPipeline);
+
+   objects_laserPipeline.map(objectBuffers_laserPipeline.memory, device);
 
    laserPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBuffers_laserPipeline.infoSet);
    laserPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, &storageBuffers_laserPipeline.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, &objectBuffers_laserPipeline.infoSet);
    laserPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
       VK_SHADER_STAGE_FRAGMENT_BIT, &laserTextureImageDescriptor);
@@ -573,12 +573,12 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_explosionPipeline);
-
-   objects_explosionPipeline.map(storageBuffers_explosionPipeline.memory, device);
+                   objectBuffers_explosionPipeline);
+
+   objects_explosionPipeline.map(objectBuffers_explosionPipeline.memory, device);
 
    explosionPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
       VK_SHADER_STAGE_VERTEX_BIT, &uniformBuffers_explosionPipeline.infoSet);
    explosionPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      VK_SHADER_STAGE_VERTEX_BIT, &storageBuffers_explosionPipeline.infoSet);
+      VK_SHADER_STAGE_VERTEX_BIT, &objectBuffers_explosionPipeline.infoSet);
 
    explosionPipeline.createDescriptorSetLayout();
@@ -1082,14 +1082,14 @@
 
    if (objects_modelPipeline.resized) {
-      objects_modelPipeline.unmap(storageBuffers_modelPipeline.memory, device);
-
-      resizeBufferSet(storageBuffers_modelPipeline, objects_modelPipeline.memorySize(), resourceCommandPool,
+      objects_modelPipeline.unmap(objectBuffers_modelPipeline.memory, device);
+
+      resizeBufferSet(objectBuffers_modelPipeline, objects_modelPipeline.memorySize(), resourceCommandPool,
                       graphicsQueue, true);
 
-      objects_modelPipeline.map(storageBuffers_modelPipeline.memory, device);
+      objects_modelPipeline.map(objectBuffers_modelPipeline.memory, device);
 
       objects_modelPipeline.resize();
 
-      modelPipeline.updateDescriptorInfo(1, &storageBuffers_modelPipeline.infoSet, swapChainImages.size());
+      modelPipeline.updateDescriptorInfo(1, &objectBuffers_modelPipeline.infoSet, swapChainImages.size());
    }
 
@@ -1112,18 +1112,18 @@
 
    VulkanUtils::copyDataToMappedMemory(device, objects_modelPipeline.data(), objects_modelPipeline.mapped(imageIndex),
-                                       storageBuffers_modelPipeline.memory[imageIndex],
+                                       objectBuffers_modelPipeline.memory[imageIndex],
                                        objects_modelPipeline.memorySize(), true);
 
    if (objects_shipPipeline.resized) {
-      objects_shipPipeline.unmap(storageBuffers_shipPipeline.memory, device);
-
-      resizeBufferSet(storageBuffers_shipPipeline, objects_shipPipeline.memorySize(), resourceCommandPool,
+      objects_shipPipeline.unmap(objectBuffers_shipPipeline.memory, device);
+
+      resizeBufferSet(objectBuffers_shipPipeline, objects_shipPipeline.memorySize(), resourceCommandPool,
                       graphicsQueue, true);
 
-      objects_shipPipeline.map(storageBuffers_shipPipeline.memory, device);
+      objects_shipPipeline.map(objectBuffers_shipPipeline.memory, device);
 
       objects_shipPipeline.resize();
 
-      shipPipeline.updateDescriptorInfo(1, &storageBuffers_shipPipeline.infoSet, swapChainImages.size());
+      shipPipeline.updateDescriptorInfo(1, &objectBuffers_shipPipeline.infoSet, swapChainImages.size());
    }
 
@@ -1142,18 +1142,18 @@
 
    VulkanUtils::copyDataToMappedMemory(device, objects_shipPipeline.data(), objects_shipPipeline.mapped(imageIndex),
-                                       storageBuffers_shipPipeline.memory[imageIndex],
+                                       objectBuffers_shipPipeline.memory[imageIndex],
                                        objects_shipPipeline.memorySize(), true);
 
    if (objects_asteroidPipeline.resized) {
-      objects_asteroidPipeline.unmap(storageBuffers_asteroidPipeline.memory, device);
-
-      resizeBufferSet(storageBuffers_asteroidPipeline, objects_asteroidPipeline.memorySize(), resourceCommandPool,
+      objects_asteroidPipeline.unmap(objectBuffers_asteroidPipeline.memory, device);
+
+      resizeBufferSet(objectBuffers_asteroidPipeline, objects_asteroidPipeline.memorySize(), resourceCommandPool,
                       graphicsQueue, true);
 
-      objects_asteroidPipeline.map(storageBuffers_asteroidPipeline.memory, device);
+      objects_asteroidPipeline.map(objectBuffers_asteroidPipeline.memory, device);
 
       objects_asteroidPipeline.resize();
 
-      asteroidPipeline.updateDescriptorInfo(1, &storageBuffers_asteroidPipeline.infoSet, swapChainImages.size());
+      asteroidPipeline.updateDescriptorInfo(1, &objectBuffers_asteroidPipeline.infoSet, swapChainImages.size());
    }
 
@@ -1195,18 +1195,18 @@
 
    VulkanUtils::copyDataToMappedMemory(device, objects_asteroidPipeline.data(), objects_asteroidPipeline.mapped(imageIndex),
-                                       storageBuffers_asteroidPipeline.memory[imageIndex],
+                                       objectBuffers_asteroidPipeline.memory[imageIndex],
                                        objects_asteroidPipeline.memorySize(), true);
 
    if (objects_laserPipeline.resized) {
-      objects_laserPipeline.unmap(storageBuffers_laserPipeline.memory, device);
-
-      resizeBufferSet(storageBuffers_laserPipeline, objects_laserPipeline.memorySize(), resourceCommandPool,
+      objects_laserPipeline.unmap(objectBuffers_laserPipeline.memory, device);
+
+      resizeBufferSet(objectBuffers_laserPipeline, objects_laserPipeline.memorySize(), resourceCommandPool,
                       graphicsQueue, true);
 
-      objects_laserPipeline.map(storageBuffers_laserPipeline.memory, device);
+      objects_laserPipeline.map(objectBuffers_laserPipeline.memory, device);
 
       objects_laserPipeline.resize();
 
-      laserPipeline.updateDescriptorInfo(1, &storageBuffers_laserPipeline.infoSet, swapChainImages.size());
+      laserPipeline.updateDescriptorInfo(1, &objectBuffers_laserPipeline.infoSet, swapChainImages.size());
    }
 
@@ -1231,18 +1231,18 @@
 
    VulkanUtils::copyDataToMappedMemory(device, objects_laserPipeline.data(), objects_laserPipeline.mapped(imageIndex),
-                                       storageBuffers_laserPipeline.memory[imageIndex],
+                                       objectBuffers_laserPipeline.memory[imageIndex],
                                        objects_laserPipeline.memorySize(), true);
 
    if (objects_explosionPipeline.resized) {
-      objects_explosionPipeline.unmap(storageBuffers_explosionPipeline.memory, device);
-
-      resizeBufferSet(storageBuffers_explosionPipeline, objects_explosionPipeline.memorySize(), resourceCommandPool,
+      objects_explosionPipeline.unmap(objectBuffers_explosionPipeline.memory, device);
+
+      resizeBufferSet(objectBuffers_explosionPipeline, objects_explosionPipeline.memorySize(), resourceCommandPool,
                       graphicsQueue, true);
 
-      objects_explosionPipeline.map(storageBuffers_explosionPipeline.memory, device);
+      objects_explosionPipeline.map(objectBuffers_explosionPipeline.memory, device);
 
       objects_explosionPipeline.resize();
 
-      explosionPipeline.updateDescriptorInfo(1, &storageBuffers_explosionPipeline.infoSet, swapChainImages.size());
+      explosionPipeline.updateDescriptorInfo(1, &objectBuffers_explosionPipeline.infoSet, swapChainImages.size());
    }
 
@@ -1266,5 +1266,5 @@
 
    VulkanUtils::copyDataToMappedMemory(device, objects_explosionPipeline.data(), objects_explosionPipeline.mapped(imageIndex),
-                                       storageBuffers_explosionPipeline.memory[imageIndex],
+                                       objectBuffers_explosionPipeline.memory[imageIndex],
                                        objects_explosionPipeline.memorySize(), true);
 }
@@ -2317,7 +2317,7 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_modelPipeline);
-
-    objects_modelPipeline.map(storageBuffers_modelPipeline.memory, device);
+                   objectBuffers_modelPipeline);
+
+    objects_modelPipeline.map(objectBuffers_modelPipeline.memory, device);
 
    modelPipeline.updateRenderPass(renderPass);
@@ -2337,7 +2337,7 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_shipPipeline);
-
-    objects_shipPipeline.map(storageBuffers_shipPipeline.memory, device);
+                   objectBuffers_shipPipeline);
+
+    objects_shipPipeline.map(objectBuffers_shipPipeline.memory, device);
 
    shipPipeline.updateRenderPass(renderPass);
@@ -2357,7 +2357,7 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_asteroidPipeline);
-
-    objects_asteroidPipeline.map(storageBuffers_asteroidPipeline.memory, device);
+                   objectBuffers_asteroidPipeline);
+
+    objects_asteroidPipeline.map(objectBuffers_asteroidPipeline.memory, device);
 
    asteroidPipeline.updateRenderPass(renderPass);
@@ -2377,7 +2377,7 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_laserPipeline);
-
-    objects_laserPipeline.map(storageBuffers_laserPipeline.memory, device);
+                   objectBuffers_laserPipeline);
+
+    objects_laserPipeline.map(objectBuffers_laserPipeline.memory, device);
 
    laserPipeline.updateRenderPass(renderPass);
@@ -2397,7 +2397,7 @@
                    | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                   storageBuffers_explosionPipeline);
-
-    objects_explosionPipeline.map(storageBuffers_explosionPipeline.memory, device);
+                   objectBuffers_explosionPipeline);
+
+    objects_explosionPipeline.map(objectBuffers_explosionPipeline.memory, device);
 
    explosionPipeline.updateRenderPass(renderPass);
@@ -2430,9 +2430,9 @@
    }
 
-   objects_modelPipeline.unmap(storageBuffers_modelPipeline.memory, device);
-
-   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);
+   objects_modelPipeline.unmap(objectBuffers_modelPipeline.memory, device);
+
+   for (size_t i = 0; i < objectBuffers_modelPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, objectBuffers_modelPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, objectBuffers_modelPipeline.memory[i], nullptr);
    }
 
@@ -2446,9 +2446,9 @@
    }
 
-   objects_shipPipeline.unmap(storageBuffers_shipPipeline.memory, device);
-
-   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);
+   objects_shipPipeline.unmap(objectBuffers_shipPipeline.memory, device);
+
+   for (size_t i = 0; i < objectBuffers_shipPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, objectBuffers_shipPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, objectBuffers_shipPipeline.memory[i], nullptr);
    }
 
@@ -2462,9 +2462,9 @@
    }
 
-   objects_asteroidPipeline.unmap(storageBuffers_asteroidPipeline.memory, device);
-
-   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);
+   objects_asteroidPipeline.unmap(objectBuffers_asteroidPipeline.memory, device);
+
+   for (size_t i = 0; i < objectBuffers_asteroidPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, objectBuffers_asteroidPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, objectBuffers_asteroidPipeline.memory[i], nullptr);
    }
 
@@ -2478,9 +2478,9 @@
    }
 
-   objects_laserPipeline.unmap(storageBuffers_laserPipeline.memory, device);
-
-   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);
+   objects_laserPipeline.unmap(objectBuffers_laserPipeline.memory, device);
+
+   for (size_t i = 0; i < objectBuffers_laserPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, objectBuffers_laserPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, objectBuffers_laserPipeline.memory[i], nullptr);
    }
 
@@ -2494,9 +2494,9 @@
    }
 
-   objects_explosionPipeline.unmap(storageBuffers_explosionPipeline.memory, device);
-
-   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);
+   objects_explosionPipeline.unmap(objectBuffers_explosionPipeline.memory, device);
+
+   for (size_t i = 0; i < objectBuffers_explosionPipeline.buffers.size(); i++) {
+      vkDestroyBuffer(device, objectBuffers_explosionPipeline.buffers[i], nullptr);
+      vkFreeMemory(device, objectBuffers_explosionPipeline.memory[i], nullptr);
    }
 
