KRDeviceManager::getDeviceInfo refactored to KRDeviceManager::getDevice, and now returns a unique_ptr.

Now freeing vertex and index buffers.

kraken/KRDeviceManager.cpp

@@ -189,9 +189,9 @@ void KRDeviceManager::createDevices()
   }
 }
 
-KRDevice& KRDeviceManager::getDeviceInfo(KrDeviceHandle handle)
+std::unique_ptr<KRDevice>& KRDeviceManager::getDevice(KrDeviceHandle handle)
 {
-  return *m_devices[handle];
+  return m_devices[handle];
 }
 
 VkInstance& KRDeviceManager::getVulkanInstance()

kraken/KRDeviceManager.h

@@ -47,7 +47,7 @@ public:
   bool haveVulkan() const;
   bool haveDevice() const;
 
-  KRDevice& getDeviceInfo(KrDeviceHandle handle);
+  std::unique_ptr<KRDevice>& getDevice(KrDeviceHandle handle);
   VkInstance& getVulkanInstance();
   KrSurfaceHandle getBestDeviceForSurface(const VkSurfaceKHR& surface);
   unordered_map<KrDeviceHandle, std::unique_ptr<KRDevice>>& getDevices();

kraken/KRMeshManager.cpp

@@ -571,12 +571,13 @@ void KRMeshManager::KRVBOData::init(KRMeshManager *manager, KRDataBlock &data, K
 
 KRMeshManager::KRVBOData::~KRVBOData()
 {
+    // TODO - This needs to be done by the streamer thread, and asserted here...
     unload();
 }
 
 void KRMeshManager::KRVBOData::load()
 {
-  // TODO - We should load on each GPU only if there is a surface using the mesh
+    // TODO - We should load on each GPU only if there is a surface using the mesh
     if(isVBOLoaded()) {
         return;
     }
@@ -681,29 +682,28 @@ void KRMeshManager::KRVBOData::load()
 
 void KRMeshManager::KRVBOData::unload()
 {
-  // TODO - We need to properly unload these in the streamer thread
+  KRDeviceManager* deviceManager = m_manager->getContext().getDeviceManager();
-    if(isVBOLoaded()) {
+  for (int i = 0; i < KRENGINE_MAX_GPU_COUNT; i++) {
-        m_manager->m_vboMemUsed -= getSize();
+    AllocationInfo& allocation = m_allocations[i];
+    if (allocation.device) {
+      std::unique_ptr<KRDevice>& device = deviceManager->getDevice(allocation.device);
+      if (device) {
+        VmaAllocator allocator = device->getAllocator();
+        vmaDestroyBuffer(allocator, allocation.vertex_buffer, allocation.vertex_allocation);
+        if (allocation.index_buffer) {
+          vmaDestroyBuffer(allocator, allocation.index_buffer, allocation.index_allocation);
+        }
+      }
     }
+    memset(&allocation, 0, sizeof(AllocationInfo));
+  }
 
-#if GL_OES_vertex_array_object
+  if(isVBOLoaded()) {
-    if(m_vao_handle != -1) {
+      m_manager->m_vboMemUsed -= getSize();
-        GLDEBUG(glDeleteVertexArraysOES(1, &m_vao_handle));
+  }
-        m_vao_handle = -1;
-    }
-#endif
-    if(m_vbo_handle != -1) {
-        GLDEBUG(glDeleteBuffers(1, &m_vbo_handle));
-        m_vbo_handle = -1;
-    }
     
-    if(m_vbo_handle_indexes != -1) {
+  m_is_vbo_loaded = false;
-        GLDEBUG(glDeleteBuffers(1, &m_vbo_handle_indexes));
+  m_is_vbo_ready = false;
-        m_vbo_handle_indexes = -1;
-    }
-    
-    m_is_vbo_loaded = false;
-    m_is_vbo_ready = false;
 }
 
 void KRMeshManager::KRVBOData::bind()

kraken/KRPipeline.cpp

@@ -116,7 +116,8 @@ KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, VkFormat
   m_pipelineLayout = nullptr;
   m_graphicsPipeline = nullptr;
   m_renderPass = nullptr;
-  KRDevice& device = m_pContext->getDeviceManager()->getDeviceInfo(deviceHandle);
+  KRDevice& device = *m_pContext->getDeviceManager()->getDevice(deviceHandle);
+  // TODO - Handle device removal
 
   strcpy(m_szKey, szKey);
 

kraken/KRPresentationThread.cpp

@@ -105,7 +105,8 @@ void KRPresentationThread::renderFrame()
 
   for (auto surfaceItr = surfaces.begin(); surfaceItr != surfaces.end(); surfaceItr++) {
     KRSurface& surface = *(*surfaceItr).second;
-    KRDevice& device = m_pContext->getDeviceManager()->getDeviceInfo(surface.m_deviceHandle);
+    KRDevice& device = *m_pContext->getDeviceManager()->getDevice(surface.m_deviceHandle);
+    // TODO - Handle device removal
 
     VkSurfaceCapabilitiesKHR surfaceCapabilities{};
     vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device.m_device, surface.m_surface, &surfaceCapabilities);

kraken/KRSurface.cpp

@@ -71,14 +71,14 @@ KrResult KRSurface::initialize()
     return KR_ERROR_NO_DEVICE;
   }
 
-  KRDevice* deviceInfo = &m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle);
+  std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
 
   VkSemaphoreCreateInfo semaphoreInfo{};
   semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-  if (vkCreateSemaphore(deviceInfo->m_logicalDevice, &semaphoreInfo, nullptr, &m_imageAvailableSemaphore) != VK_SUCCESS) {
+  if (vkCreateSemaphore(device->m_logicalDevice, &semaphoreInfo, nullptr, &m_imageAvailableSemaphore) != VK_SUCCESS) {
     return KR_ERROR_VULKAN;
   }
-  if (vkCreateSemaphore(deviceInfo->m_logicalDevice, &semaphoreInfo, nullptr, &m_renderFinishedSemaphore) != VK_SUCCESS) {
+  if (vkCreateSemaphore(device->m_logicalDevice, &semaphoreInfo, nullptr, &m_renderFinishedSemaphore) != VK_SUCCESS) {
     return KR_ERROR_VULKAN;
   }
 
@@ -87,17 +87,17 @@ KrResult KRSurface::initialize()
 
 void KRSurface::destroy()
 {
-  KRDevice& deviceInfo = m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle);
-
   destroySwapChain();
 
-  if (m_renderFinishedSemaphore != VK_NULL_HANDLE) {
+  std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
-    vkDestroySemaphore(deviceInfo.m_logicalDevice, m_renderFinishedSemaphore, nullptr);
+
+  if (device && m_renderFinishedSemaphore != VK_NULL_HANDLE) {
+    vkDestroySemaphore(device->m_logicalDevice, m_renderFinishedSemaphore, nullptr);
     m_renderFinishedSemaphore = VK_NULL_HANDLE;
   }
   
-  if (m_imageAvailableSemaphore != VK_NULL_HANDLE) {
+  if (device && m_imageAvailableSemaphore != VK_NULL_HANDLE) {
-    vkDestroySemaphore(deviceInfo.m_logicalDevice, m_imageAvailableSemaphore, nullptr);
+    vkDestroySemaphore(device->m_logicalDevice, m_imageAvailableSemaphore, nullptr);
     m_imageAvailableSemaphore = VK_NULL_HANDLE;
   }
   
@@ -105,33 +105,32 @@ void KRSurface::destroy()
     vkDestroySurfaceKHR(m_pContext->getDeviceManager()->getVulkanInstance(), m_surface, nullptr);
     m_surface = VK_NULL_HANDLE;
   }
-
 }
 
 KrResult KRSurface::createSwapChain()
 {
-  KRDevice* deviceInfo = &m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle);
+  std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
 
   VkSurfaceCapabilitiesKHR surfaceCapabilities{};
-  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(deviceInfo->m_device, m_surface, &surfaceCapabilities);
+  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device->m_device, m_surface, &surfaceCapabilities);
 
   std::vector<VkSurfaceFormatKHR> surfaceFormats;
   uint32_t formatCount = 0;
-  vkGetPhysicalDeviceSurfaceFormatsKHR(deviceInfo->m_device, m_surface, &formatCount, nullptr);
+  vkGetPhysicalDeviceSurfaceFormatsKHR(device->m_device, m_surface, &formatCount, nullptr);
 
   if (formatCount != 0) {
     surfaceFormats.resize(formatCount);
-    vkGetPhysicalDeviceSurfaceFormatsKHR(deviceInfo->m_device, m_surface, &formatCount, surfaceFormats.data());
+    vkGetPhysicalDeviceSurfaceFormatsKHR(device->m_device, m_surface, &formatCount, surfaceFormats.data());
   }
 
   std::vector<VkPresentModeKHR> surfacePresentModes;
 
   uint32_t presentModeCount = 0;
-  vkGetPhysicalDeviceSurfacePresentModesKHR(deviceInfo->m_device, m_surface, &presentModeCount, nullptr);
+  vkGetPhysicalDeviceSurfacePresentModesKHR(device->m_device, m_surface, &presentModeCount, nullptr);
 
   if (presentModeCount != 0) {
     surfacePresentModes.resize(presentModeCount);
-    vkGetPhysicalDeviceSurfacePresentModesKHR(deviceInfo->m_device, m_surface, &presentModeCount, surfacePresentModes.data());
+    vkGetPhysicalDeviceSurfacePresentModesKHR(device->m_device, m_surface, &presentModeCount, surfacePresentModes.data());
   }
 
   VkSurfaceFormatKHR selectedSurfaceFormat = surfaceFormats[0];
@@ -180,10 +179,10 @@ KrResult KRSurface::createSwapChain()
   swapChainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
   uint32_t queueFamilyIndices[] = {
-    deviceInfo->m_graphicsFamilyQueueIndex,
+    device->m_graphicsFamilyQueueIndex,
-    deviceInfo->m_computeFamilyQueueIndex
+    device->m_computeFamilyQueueIndex
   };
-  if (deviceInfo->m_graphicsFamilyQueueIndex == deviceInfo->m_computeFamilyQueueIndex) {
+  if (device->m_graphicsFamilyQueueIndex == device->m_computeFamilyQueueIndex) {
     swapChainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
     swapChainCreateInfo.queueFamilyIndexCount = 0;
     swapChainCreateInfo.pQueueFamilyIndices = nullptr;
@@ -200,13 +199,13 @@ KrResult KRSurface::createSwapChain()
   swapChainCreateInfo.clipped = VK_TRUE;
   swapChainCreateInfo.oldSwapchain = VK_NULL_HANDLE;
 
-  if (vkCreateSwapchainKHR(deviceInfo->m_logicalDevice, &swapChainCreateInfo, nullptr, &m_swapChain) != VK_SUCCESS) {
+  if (vkCreateSwapchainKHR(device->m_logicalDevice, &swapChainCreateInfo, nullptr, &m_swapChain) != VK_SUCCESS) {
     return KR_ERROR_VULKAN_SWAP_CHAIN;
   }
 
-  vkGetSwapchainImagesKHR(deviceInfo->m_logicalDevice, m_swapChain, &imageCount, nullptr);
+  vkGetSwapchainImagesKHR(device->m_logicalDevice, m_swapChain, &imageCount, nullptr);
   m_swapChainImages.resize(imageCount);
-  vkGetSwapchainImagesKHR(deviceInfo->m_logicalDevice, m_swapChain, &imageCount, m_swapChainImages.data());
+  vkGetSwapchainImagesKHR(device->m_logicalDevice, m_swapChain, &imageCount, m_swapChainImages.data());
 
   m_swapChainImageFormat = selectedSurfaceFormat.format;
 
@@ -226,7 +225,7 @@ KrResult KRSurface::createSwapChain()
     createInfo.subresourceRange.levelCount = 1;
     createInfo.subresourceRange.baseArrayLayer = 0;
     createInfo.subresourceRange.layerCount = 1;
-    if (vkCreateImageView(deviceInfo->m_logicalDevice, &createInfo, nullptr, &m_swapChainImageViews[i]) != VK_SUCCESS) {
+    if (vkCreateImageView(device->m_logicalDevice, &createInfo, nullptr, &m_swapChainImageViews[i]) != VK_SUCCESS) {
       return KR_ERROR_VULKAN_SWAP_CHAIN;
     }
   }
@@ -249,7 +248,7 @@ KrResult KRSurface::createSwapChain()
     framebufferInfo.height = m_swapChainExtent.height;
     framebufferInfo.layers = 1;
 
-    if (vkCreateFramebuffer(deviceInfo->m_logicalDevice, &framebufferInfo, nullptr, &m_swapChainFramebuffers[i]) != VK_SUCCESS) {
+    if (vkCreateFramebuffer(device->m_logicalDevice, &framebufferInfo, nullptr, &m_swapChainFramebuffers[i]) != VK_SUCCESS) {
       return KR_ERROR_VULKAN_FRAMEBUFFER;
     }
   }
@@ -262,22 +261,24 @@ void KRSurface::destroySwapChain()
   KRPipelineManager* pipelineManager = m_pContext->getPipelineManager();
   // TODO - Destroy the dependent pipeline..
 
-  KRDevice& deviceInfo = m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle);
+  std::unique_ptr<KRDevice>& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle);
+  // TODO - Handle device removal
+  if (device) {
+    for (auto framebuffer : m_swapChainFramebuffers) {
+      vkDestroyFramebuffer(device->m_logicalDevice, framebuffer, nullptr);
+    }
     
-  for (auto framebuffer : m_swapChainFramebuffers) {
+    for (auto imageView : m_swapChainImageViews) {
-    vkDestroyFramebuffer(deviceInfo.m_logicalDevice, framebuffer, nullptr);
+      vkDestroyImageView(device->m_logicalDevice, imageView, nullptr);
+    }
+    
+    if (m_swapChain != VK_NULL_HANDLE) {
+      vkDestroySwapchainKHR(device->m_logicalDevice, m_swapChain, nullptr);
+    }
   }
+  m_swapChain = VK_NULL_HANDLE;
   m_swapChainFramebuffers.clear();
-
-  for (auto imageView : m_swapChainImageViews) {
-    vkDestroyImageView(deviceInfo.m_logicalDevice, imageView, nullptr);
-  }
   m_swapChainImageViews.clear();
-
-  if (m_swapChain != VK_NULL_HANDLE) {
-    vkDestroySwapchainKHR(deviceInfo.m_logicalDevice, m_swapChain, nullptr);
-    m_swapChain = VK_NULL_HANDLE;
-  }
 }
 
 KrResult KRSurface::recreateSwapChain()