Index: vulkan-ref.cpp
===================================================================
--- vulkan-ref.cpp	(revision fa9fa1ce290a1ee0872d5c05323aa3737cdee04b)
+++ vulkan-ref.cpp	(revision 7563b8aac8d663f36cba4800dd7b37bed15f9ecd)
@@ -102,8 +102,10 @@
 
    size_t numVertices; // Currently unused
+   size_t vertexCapacity;
    VkBuffer vertexBuffer;
    VkDeviceMemory vertexBufferMemory;
 
    size_t numIndices;
+   size_t indexCapacity;
    VkBuffer indexBuffer;
    VkDeviceMemory indexBufferMemory;
@@ -226,4 +228,6 @@
 
       size_t currentFrame = 0;
+
+      size_t numPlanes = 0; // temp
 
 /*** START OF REFACTORED CODE ***/
@@ -369,4 +373,5 @@
          createDescriptorSetLayout(scenePipeline);
 
+         numPlanes = 2;
 
          vector<OverlayVertex> overlayVertices = {
@@ -808,8 +813,10 @@
 
          info.numVertices = numVertices;
-         createVertexBuffer(info, vertexData, vertexSize * numVertices);
+         info.vertexCapacity = numVertices * 2;
+         createVertexBuffer(info, vertexData, vertexSize);
 
          info.numIndices = numIndices;
-         createIndexBuffer(info, indexData, indexSize * numIndices);
+         info.indexCapacity = numIndices * 2;
+         createIndexBuffer(info, indexData, indexSize);
       }
 
@@ -1388,5 +1395,8 @@
       }
 
-      void createVertexBuffer(GraphicsPipelineInfo& info, const void* vertexData, VkDeviceSize bufferSize) {
+      void createVertexBuffer(GraphicsPipelineInfo& info, const void* vertexData, int vertexSize) {
+         VkDeviceSize bufferSize = info.numVertices * vertexSize;
+         VkDeviceSize bufferCapacity = info.vertexCapacity * vertexSize;
+
          VkBuffer stagingBuffer;
          VkDeviceMemory stagingBufferMemory;
@@ -1400,8 +1410,8 @@
          vkUnmapMemory(device, stagingBufferMemory);
 
-         createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+         createBuffer(bufferCapacity, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
             VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, info.vertexBuffer, info.vertexBufferMemory);
 
-         copyBuffer(stagingBuffer, info.vertexBuffer, bufferSize);
+         copyBuffer(stagingBuffer, info.vertexBuffer, 0, 0, bufferSize);
 
          vkDestroyBuffer(device, stagingBuffer, nullptr);
@@ -1409,5 +1419,8 @@
       }
 
-      void createIndexBuffer(GraphicsPipelineInfo& info, const void* indexData, VkDeviceSize bufferSize) {
+      void createIndexBuffer(GraphicsPipelineInfo& info, const void* indexData, int indexSize) {
+         VkDeviceSize bufferSize = info.numIndices * indexSize;
+         VkDeviceSize bufferCapacity = info.indexCapacity * indexSize;
+
          VkBuffer stagingBuffer;
          VkDeviceMemory stagingBufferMemory;
@@ -1421,8 +1434,8 @@
          vkUnmapMemory(device, stagingBufferMemory);
 
-         createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+         createBuffer(bufferCapacity, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
             VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, info.indexBuffer, info.indexBufferMemory);
 
-         copyBuffer(stagingBuffer, info.indexBuffer, bufferSize);
+         copyBuffer(stagingBuffer, info.indexBuffer, 0, 0, bufferSize);
 
          vkDestroyBuffer(device, stagingBuffer, nullptr);
@@ -1474,9 +1487,27 @@
       }
 
-      void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
+      void copyDataToBuffer(const void* srcData, VkBuffer dst, VkDeviceSize dstOffset, VkDeviceSize dataSize) {
+         VkBuffer stagingBuffer;
+         VkDeviceMemory stagingBufferMemory;
+         createBuffer(dataSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+            stagingBuffer, stagingBufferMemory);
+
+         void* data;
+         vkMapMemory(device, stagingBufferMemory, 0, dataSize, 0, &data);
+         memcpy(data, srcData, (size_t) dataSize);
+         vkUnmapMemory(device, stagingBufferMemory);
+
+         copyBuffer(stagingBuffer, dst, 0, dstOffset, dataSize);
+
+         vkDestroyBuffer(device, stagingBuffer, nullptr);
+         vkFreeMemory(device, stagingBufferMemory, nullptr);
+      }
+
+      void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize srcOffset, VkDeviceSize dstOffset,
+            VkDeviceSize size) {
          VkCommandBuffer commandBuffer = beginSingleTimeCommands();
 
-         VkBufferCopy copyRegion = {};
-         copyRegion.size = size;
+         VkBufferCopy copyRegion = { srcOffset, dstOffset, size };
          vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
 
@@ -1678,4 +1709,35 @@
       }
 
+      bool addObjectToScene(GraphicsPipelineInfo& info,
+            const void* vertexData, int vertexSize, size_t numVertices,
+            vector<uint16_t>& indices, size_t numIndices) {
+         int indexSize = sizeof(uint16_t);
+
+         for (uint16_t& idx : indices) {
+            idx += info.numVertices;
+         }
+
+         if (info.numVertices + numVertices > info.vertexCapacity) {
+            cout << "ERROR: Need to resize vertex buffers" << endl;
+         } else if (info.numIndices + numIndices > info.indexCapacity) {
+            cout << "ERROR: Need to resize index buffers" << endl;
+         } else {
+            cout << "Added object to scene" << endl;
+
+            copyDataToBuffer(vertexData, info.vertexBuffer, info.numVertices * vertexSize, numVertices * vertexSize);
+            info.numVertices += numVertices;
+
+            copyDataToBuffer(indices.data(), info.indexBuffer, info.numIndices * indexSize, numIndices * indexSize);
+            info.numIndices += numIndices;
+
+            vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data());
+            createCommandBuffers();
+
+            return true;
+         }
+
+         return false;
+      }
+
 /*** START OF REFACTORED CODE ***/
       void mainLoop() {
@@ -1690,5 +1752,22 @@
                }
                if (e.type == SDL_KEYDOWN) {
-                  if (e.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
+                  if (e.key.keysym.sym == SDLK_SPACE) {
+                     float zOffset = -0.5f + (0.5f * numPlanes);
+                     vector<Vertex> vertices = {
+                        {{-0.5f, -0.5f,  zOffset}, {1.0f, 0.0f, 0.0f}, {0.0f, 1.0f}},
+                        {{ 0.5f, -0.5f,  zOffset}, {0.0f, 1.0f, 0.0f}, {1.0f, 1.0f}},
+                        {{ 0.5f,  0.5f,  zOffset}, {0.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
+                        {{-0.5f,  0.5f,  zOffset}, {1.0f, 1.0f, 1.0f}, {0.0f, 0.0f}}
+                     };
+                     vector<uint16_t> indices = {
+                        0, 1, 2, 2, 3, 0
+                     };
+
+                     if (addObjectToScene(scenePipeline,
+                           vertices.data(), sizeof(Vertex), vertices.size(),
+                           indices, indices.size())) {
+                        numPlanes++;
+                     }
+                  } else if (e.key.keysym.sym == SDLK_ESCAPE) {
                      quit = true;
                   }