From 100ab0d3de6c69b4df661279db35d2c8923fabe6 Mon Sep 17 00:00:00 2001 From: kearwood Date: Sat, 22 Jan 2022 01:32:32 -0800 Subject: [PATCH] KRDeviceManager::getDeviceInfo refactored to KRDeviceManager::getDevice, and now returns a unique_ptr. Now freeing vertex and index buffers. --- kraken/KRDeviceManager.cpp | 4 +- kraken/KRDeviceManager.h | 2 +- kraken/KRMeshManager.cpp | 44 +++++++++---------- kraken/KRPipeline.cpp | 3 +- kraken/KRPresentationThread.cpp | 3 +- kraken/KRSurface.cpp | 77 +++++++++++++++++---------------- 6 files changed, 68 insertions(+), 65 deletions(-) diff --git a/kraken/KRDeviceManager.cpp b/kraken/KRDeviceManager.cpp index 16a6822..95c2070 100644 --- a/kraken/KRDeviceManager.cpp +++ b/kraken/KRDeviceManager.cpp @@ -189,9 +189,9 @@ void KRDeviceManager::createDevices() } } -KRDevice& KRDeviceManager::getDeviceInfo(KrDeviceHandle handle) +std::unique_ptr& KRDeviceManager::getDevice(KrDeviceHandle handle) { - return *m_devices[handle]; + return m_devices[handle]; } VkInstance& KRDeviceManager::getVulkanInstance() diff --git a/kraken/KRDeviceManager.h b/kraken/KRDeviceManager.h index 6358f97..a4ecb7a 100644 --- a/kraken/KRDeviceManager.h +++ b/kraken/KRDeviceManager.h @@ -47,7 +47,7 @@ public: bool haveVulkan() const; bool haveDevice() const; - KRDevice& getDeviceInfo(KrDeviceHandle handle); + std::unique_ptr& getDevice(KrDeviceHandle handle); VkInstance& getVulkanInstance(); KrSurfaceHandle getBestDeviceForSurface(const VkSurfaceKHR& surface); unordered_map>& getDevices(); diff --git a/kraken/KRMeshManager.cpp b/kraken/KRMeshManager.cpp index b4ec010..4e54587 100755 --- a/kraken/KRMeshManager.cpp +++ b/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 - if(isVBOLoaded()) { - m_manager->m_vboMemUsed -= getSize(); + KRDeviceManager* deviceManager = m_manager->getContext().getDeviceManager(); + for (int i = 0; i < KRENGINE_MAX_GPU_COUNT; i++) { + AllocationInfo& allocation = m_allocations[i]; + if (allocation.device) { + std::unique_ptr& 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(isVBOLoaded()) { + m_manager->m_vboMemUsed -= getSize(); + } -#if GL_OES_vertex_array_object - if(m_vao_handle != -1) { - 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) { - GLDEBUG(glDeleteBuffers(1, &m_vbo_handle_indexes)); - m_vbo_handle_indexes = -1; - } - - m_is_vbo_loaded = false; - m_is_vbo_ready = false; + m_is_vbo_loaded = false; + m_is_vbo_ready = false; } void KRMeshManager::KRVBOData::bind() diff --git a/kraken/KRPipeline.cpp b/kraken/KRPipeline.cpp index 4503ec7..189ae86 100644 --- a/kraken/KRPipeline.cpp +++ b/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); diff --git a/kraken/KRPresentationThread.cpp b/kraken/KRPresentationThread.cpp index b4db27c..ea3e7f4 100644 --- a/kraken/KRPresentationThread.cpp +++ b/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); diff --git a/kraken/KRSurface.cpp b/kraken/KRSurface.cpp index 13c1d9c..290ad2f 100644 --- a/kraken/KRSurface.cpp +++ b/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& 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) { - vkDestroySemaphore(deviceInfo.m_logicalDevice, m_renderFinishedSemaphore, nullptr); + + std::unique_ptr& device = m_pContext->getDeviceManager()->getDevice(m_deviceHandle); + + 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) { - vkDestroySemaphore(deviceInfo.m_logicalDevice, m_imageAvailableSemaphore, nullptr); + if (device && m_imageAvailableSemaphore != VK_NULL_HANDLE) { + 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& 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 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 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, - deviceInfo->m_computeFamilyQueueIndex + device->m_graphicsFamilyQueueIndex, + 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); - - for (auto framebuffer : m_swapChainFramebuffers) { - vkDestroyFramebuffer(deviceInfo.m_logicalDevice, framebuffer, nullptr); + std::unique_ptr& 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 imageView : m_swapChainImageViews) { + 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()