kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Now freeing vertex and index buffers.
This commit is contained in:
Kearwood Gilbert
2022-01-22 01:32:32 -08:00
parent ad596a82f9
commit 100ab0d3de
6 changed files with 68 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
kraken/KRDeviceManager.cpp
View File

@@ -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()

2
kraken/KRDeviceManager.h
View File

@@ -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();

42
kraken/KRMeshManager.cpp
View File

@@ -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<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(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(isVBOLoaded()) {
m_manager->m_vboMemUsed -= getSize();
}
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()

3
kraken/KRPipeline.cpp
View File

@@ -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);

3
kraken/KRPresentationThread.cpp
View File

@@ -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);

73
kraken/KRSurface.cpp
View File

@@ -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) {
vkDestroySemaphore(deviceInfo.m_logicalDevice, m_renderFinishedSemaphore, nullptr);
std::unique_ptr<KRDevice>& 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<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,
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);
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) {
vkDestroyFramebuffer(deviceInfo.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()