Index: sdl-game.cpp
===================================================================
--- sdl-game.cpp	(revision 567fa8887807b77ef828d381dca5fd2d7d52078f)
+++ sdl-game.cpp	(revision c074f816bb2bb4e22016bed4c2547d2f76a26817)
@@ -475,5 +475,6 @@
    }
 
-   VulkanUtils::copyDataToMemory(device, object_VP_mats, uniformBuffers_modelPipeline.memory[imageIndex], 0);
+   VulkanUtils::copyDataToMemory(device, &object_VP_mats, uniformBuffers_modelPipeline.memory[imageIndex], 0,
+                                 sizeof(object_VP_mats), false);
 }
 
Index: sdl-game.hpp
===================================================================
--- sdl-game.hpp	(revision 567fa8887807b77ef828d381dca5fd2d7d52078f)
+++ sdl-game.hpp	(revision c074f816bb2bb4e22016bed4c2547d2f76a26817)
@@ -383,5 +383,5 @@
 void VulkanGame::updateBufferSet(BufferSet& set, size_t objIndex, SSBOType& ssbo) {
    for (size_t i = 0; i < set.memory.size(); i++) {
-      VulkanUtils::copyDataToMemory(device, ssbo, set.memory[i], objIndex * sizeof(SSBOType));
+      VulkanUtils::copyDataToMemory(device, &ssbo, set.memory[i], objIndex * sizeof(SSBOType), sizeof(ssbo), false);
    }
 }
Index: vulkan-game.cpp
===================================================================
--- vulkan-game.cpp	(revision 567fa8887807b77ef828d381dca5fd2d7d52078f)
+++ vulkan-game.cpp	(revision c074f816bb2bb4e22016bed4c2547d2f76a26817)
@@ -1161,13 +1161,18 @@
    explosion_UBO.cur_time = curTime;
 
-   VulkanUtils::copyDataToMemory(device, object_VP_mats, uniformBuffers_modelPipeline.memory[imageIndex], 0);
-
-   VulkanUtils::copyDataToMemory(device, ship_VP_mats, uniformBuffers_shipPipeline.memory[imageIndex], 0);
-
-   VulkanUtils::copyDataToMemory(device, asteroid_VP_mats, uniformBuffers_asteroidPipeline.memory[imageIndex], 0);
-
-   VulkanUtils::copyDataToMemory(device, laser_VP_mats, uniformBuffers_laserPipeline.memory[imageIndex], 0);
-
-   VulkanUtils::copyDataToMemory(device, explosion_UBO, uniformBuffers_explosionPipeline.memory[imageIndex], 0);
+   VulkanUtils::copyDataToMemory(device, &object_VP_mats, uniformBuffers_modelPipeline.memory[imageIndex], 0,
+                                 sizeof(object_VP_mats), false);
+
+   VulkanUtils::copyDataToMemory(device, &ship_VP_mats, uniformBuffers_shipPipeline.memory[imageIndex], 0,
+                                 sizeof(ship_VP_mats), false);
+
+   VulkanUtils::copyDataToMemory(device, &asteroid_VP_mats, uniformBuffers_asteroidPipeline.memory[imageIndex], 0,
+                                 sizeof(asteroid_VP_mats), false);
+
+   VulkanUtils::copyDataToMemory(device, &laser_VP_mats, uniformBuffers_laserPipeline.memory[imageIndex], 0,
+                                 sizeof(laser_VP_mats), false);
+
+   VulkanUtils::copyDataToMemory(device, &explosion_UBO, uniformBuffers_explosionPipeline.memory[imageIndex], 0,
+                                 sizeof(explosion_UBO), false);
 }
 
Index: vulkan-game.hpp
===================================================================
--- vulkan-game.hpp	(revision 567fa8887807b77ef828d381dca5fd2d7d52078f)
+++ vulkan-game.hpp	(revision c074f816bb2bb4e22016bed4c2547d2f76a26817)
@@ -39,9 +39,4 @@
 // TODO: Consider if there is a better way of dealing with all the vertex types and ssbo types, maybe
 // by consolidating some and trying to keep new ones to a minimum
-
-struct OverlayVertex {
-   vec3 pos;
-   vec2 texCoord;
-};
 
 struct ModelVertex {
@@ -546,5 +541,5 @@
 void VulkanGame::updateBufferSet(BufferSet& set, size_t objIndex, SSBOType& ssbo) {
    for (size_t i = 0; i < set.memory.size(); i++) {
-      VulkanUtils::copyDataToMemory(device, ssbo, set.memory[i], objIndex * sizeof(SSBOType));
+      VulkanUtils::copyDataToMemory(device, &ssbo, set.memory[i], objIndex * sizeof(SSBOType), sizeof(ssbo), false);
    }
 }
Index: vulkan-utils.hpp
===================================================================
--- vulkan-utils.hpp	(revision 567fa8887807b77ef828d381dca5fd2d7d52078f)
+++ vulkan-utils.hpp	(revision c074f816bb2bb4e22016bed4c2547d2f76a26817)
@@ -103,10 +103,10 @@
 
       template<class DataType>
-      static void copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
-                                   VkDeviceSize offset);
+      static void copyDataToMemory(VkDevice device, DataType* srcData, VkDeviceMemory bufferMemory,
+                                   VkDeviceSize offset, VkDeviceSize size, bool flush);
 
       template<class DataType>
-      static void copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
-                                   VkDeviceSize offset, VkDeviceSize size);
+      static void copyDataToMappedMemory(VkDevice device, DataType* srcData, void* mappedData,
+                                         VkDeviceMemory bufferMemory, VkDeviceSize size, bool flush);
 
       static bool hasStencilComponent(VkFormat format);
@@ -140,19 +140,37 @@
 
 template<class DataType>
-void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
-                                   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,
-                                   VkDeviceSize offset, VkDeviceSize size) {
+void VulkanUtils::copyDataToMemory(VkDevice device, DataType* srcData, VkDeviceMemory bufferMemory,
+                                   VkDeviceSize offset, VkDeviceSize size, bool flush) {
    void* data;
 
    vkMapMemory(device, bufferMemory, offset, size, 0, &data);
-   memcpy(data, &srcData, size);
+
+   memcpy(data, srcData, size);
+
+   if (flush) {
+      VkMappedMemoryRange memoryRange{};
+      memoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+      memoryRange.memory = bufferMemory;
+      memoryRange.size = size;
+
+      vkFlushMappedMemoryRanges(device, 1, &memoryRange);
+   }
+
    vkUnmapMemory(device, bufferMemory);
+}
+
+template<class DataType>
+void VulkanUtils::copyDataToMappedMemory(VkDevice device, DataType* srcData, void* mappedData,
+                                         VkDeviceMemory bufferMemory, VkDeviceSize size, bool flush) {
+   memcpy(mappedData, srcData, size);
+
+   if (flush) {
+      VkMappedMemoryRange memoryRange{};
+      memoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+      memoryRange.memory = bufferMemory;
+      memoryRange.size = size;
+
+      vkFlushMappedMemoryRanges(device, 1, &memoryRange);
+   }
 }