From a3fc0d84d4c873097b1ebe7cd099ecf3005269e9 Mon Sep 17 00:00:00 2001 From: Kearwood Gilbert Date: Tue, 17 Aug 2021 00:20:56 -0700 Subject: [PATCH] Implemented KRDeviceManager --- kraken/CMakeLists.txt | 1 + kraken/KRContext.cpp | 166 ++----------------------- kraken/KRContext.h | 14 +-- kraken/KRDeviceManager.cpp | 208 ++++++++++++++++++++++++++++++++ kraken/KRDeviceManager.h | 64 ++++++++++ kraken/KRPipeline.cpp | 2 +- kraken/KRPresentationThread.cpp | 2 +- kraken/KRSurface.cpp | 10 +- 8 files changed, 295 insertions(+), 172 deletions(-) create mode 100644 kraken/KRDeviceManager.cpp create mode 100644 kraken/KRDeviceManager.h diff --git a/kraken/CMakeLists.txt b/kraken/CMakeLists.txt index ab1c6e7..da834cd 100644 --- a/kraken/CMakeLists.txt +++ b/kraken/CMakeLists.txt @@ -23,6 +23,7 @@ add_sources(KRCamera.cpp) add_sources(KRCollider.cpp) add_sources(KRContext.cpp) add_sources(KRDevice.cpp) +add_sources(KRDeviceManager.cpp) add_sources(KRSurface.cpp) add_sources(KRSurfaceManager.cpp) add_sources(KRStreamer.cpp) diff --git a/kraken/KRContext.cpp b/kraken/KRContext.cpp index c4df353..ce0e998 100755 --- a/kraken/KRContext.cpp +++ b/kraken/KRContext.cpp @@ -37,7 +37,6 @@ #include "KRAudioSample.h" #include "KRBundle.h" #include "KRPresentationThread.h" -#include "KRSurfaceManager.h" #if defined(ANDROID) #include @@ -84,9 +83,7 @@ void *KRContext::s_log_callback_user_data = NULL; KRContext::KRContext(const KrInitializeInfo* initializeInfo) : m_streamer(*this) - , m_vulkanInstance(VK_NULL_HANDLE) , m_resourceMapSize(initializeInfo->resourceMapSize) - , m_topDeviceHandle(0) { m_presentationThread = std::make_unique(*this); m_resourceMap = (KRResource **)malloc(sizeof(KRResource*) * m_resourceMapSize); @@ -114,6 +111,7 @@ KRContext::KRContext(const KrInitializeInfo* initializeInfo) m_pUnknownManager = new KRUnknownManager(*this); m_pShaderManager = new KRShaderManager(*this); m_pSourceManager = new KRSourceManager(*this); + m_deviceManager = std::make_unique(*this); m_surfaceManager = std::make_unique(*this); m_streamingEnabled = true; @@ -133,7 +131,8 @@ KRContext::KRContext(const KrInitializeInfo* initializeInfo) #error Unsupported #endif - createDeviceContexts(); + m_deviceManager->initialize(); + m_presentationThread->start(); } @@ -195,8 +194,8 @@ KRContext::~KRContext() { m_pBundleManager = NULL; } m_surfaceManager.reset(); + m_deviceManager.reset(); - destroyDeviceContexts(); if (m_resourceMap) { delete m_resourceMap; m_resourceMap = NULL; @@ -265,6 +264,9 @@ KRSourceManager *KRContext::getSourceManager() { KRSurfaceManager* KRContext::getSurfaceManager() { return m_surfaceManager.get(); } +KRDeviceManager* KRContext::getDeviceManager() { + return m_deviceManager.get(); +} KRUnknownManager *KRContext::getUnknownManager() { return m_pUnknownManager; } @@ -754,70 +756,6 @@ void KRContext::receivedMemoryWarning() m_last_memory_warning_frame = m_current_frame; } -void -KRContext::createDeviceContexts() -{ - VkResult res = volkInitialize(); - if (res != VK_SUCCESS) { - destroyDeviceContexts(); - return; - } - - // initialize the VkApplicationInfo structure - VkApplicationInfo app_info = {}; - app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; - app_info.pNext = NULL; - app_info.pApplicationName = "Test"; // TODO - Change Me! - app_info.applicationVersion = VK_MAKE_VERSION(0, 0, 1); - app_info.pEngineName = "Kraken Engine"; - app_info.engineVersion = VK_MAKE_VERSION(0, 1, 0); - app_info.apiVersion = VK_API_VERSION_1_0; - - // VK_KHR_surface and VK_KHR_win32_surface - - char* extensions[] = { - "VK_KHR_surface", -#ifdef WIN32 - "VK_KHR_win32_surface", -#endif - }; - - // initialize the VkInstanceCreateInfo structure - VkInstanceCreateInfo inst_info = {}; - inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; - inst_info.pNext = NULL; - inst_info.flags = 0; - inst_info.pApplicationInfo = &app_info; -#ifdef WIN32 - inst_info.enabledExtensionCount = 2; -#else - inst_info.enabledExtensionCount = 1; -#endif - inst_info.ppEnabledExtensionNames = extensions; - inst_info.enabledLayerCount = 0; - inst_info.ppEnabledLayerNames = NULL; - - res = vkCreateInstance(&inst_info, NULL, &m_vulkanInstance); - if (res != VK_SUCCESS) { - destroyDeviceContexts(); - return; - } - - volkLoadInstance(m_vulkanInstance); - - createDevices(); -} - -void -KRContext::destroyDeviceContexts() -{ - const std::lock_guard lock(KRContext::g_DeviceInfoMutex); - m_devices.clear(); - if (m_vulkanInstance != VK_NULL_HANDLE) { - vkDestroyInstance(m_vulkanInstance, NULL); - m_vulkanInstance = VK_NULL_HANDLE; - } -} void KRContext::activateStreamerContext() @@ -904,34 +842,19 @@ void KRContext::removeResource(KRResource* resource) } } -KrSurfaceHandle KRContext::GetBestDeviceForSurface(const VkSurfaceKHR& surface) -{ - KrDeviceHandle deviceHandle = 0; - for (auto itr = m_devices.begin(); itr != m_devices.end(); itr++) { - KRDevice& device = *(*itr).second; - VkBool32 canPresent = false; - vkGetPhysicalDeviceSurfaceSupportKHR(device.m_device, device.m_graphicsFamilyQueueIndex, surface, &canPresent); - if (canPresent) { - deviceHandle = (*itr).first; - break; - } - } - return deviceHandle; -} - KrResult KRContext::createWindowSurface(const KrCreateWindowSurfaceInfo* createWindowSurfaceInfo) { if (createWindowSurfaceInfo->surfaceHandle < 0) { return KR_ERROR_OUT_OF_BOUNDS; } - if (m_vulkanInstance == VK_NULL_HANDLE) { + if (!m_deviceManager->haveVulkan()) { return KR_ERROR_VULKAN_REQUIRED; } if (m_surfaceHandleMap.count(createWindowSurfaceInfo->surfaceHandle)) { return KR_ERROR_DUPLICATE_HANDLE; } - if (m_devices.size() == 0) { + if (!m_deviceManager->haveDevice()) { return KR_ERROR_NO_DEVICE; } @@ -960,7 +883,7 @@ KrResult KRContext::deleteWindowSurface(const KrDeleteWindowSurfaceInfo* deleteW if (deleteWindowSurfaceInfo->surfaceHandle < 0) { return KR_ERROR_OUT_OF_BOUNDS; } - if (m_vulkanInstance == VK_NULL_HANDLE) { + if (!m_deviceManager->haveVulkan()) { return KR_ERROR_VULKAN_REQUIRED; } @@ -973,72 +896,3 @@ KrResult KRContext::deleteWindowSurface(const KrDeleteWindowSurfaceInfo* deleteW return m_surfaceManager->destroy(surfaceHandle); } - -KRDevice& KRContext::GetDeviceInfo(KrDeviceHandle handle) -{ - return *m_devices[handle]; -} - -void KRContext::createDevices() -{ - const std::lock_guard deviceLock(KRContext::g_DeviceInfoMutex); - if (m_devices.size() > 0) { - return; - } - uint32_t deviceCount = 0; - vkEnumeratePhysicalDevices(m_vulkanInstance, &deviceCount, nullptr); - if (deviceCount == 0) { - return; - } - - std::vector physicalDevices(deviceCount); - vkEnumeratePhysicalDevices(m_vulkanInstance, &deviceCount, physicalDevices.data()); - - const std::vector deviceExtensions = { - VK_KHR_SWAPCHAIN_EXTENSION_NAME - }; - - std::vector> candidateDevices; - - for (const VkPhysicalDevice& physicalDevice : physicalDevices) { - std::unique_ptr device = std::make_unique(physicalDevice); - if (!device->initialize(deviceExtensions)) { - continue; - } - - bool addDevice = false; - if (candidateDevices.empty()) { - addDevice = true; - } else { - VkPhysicalDeviceType collectedType = candidateDevices[0]->m_deviceProperties.deviceType; - if (collectedType == device->m_deviceProperties.deviceType) { - addDevice = true; - } else if (device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) { - // Discrete GPU's are always the best choice - candidateDevices.clear(); - addDevice = true; - } else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) { - // Integrated GPU's are the second best choice - candidateDevices.clear(); - addDevice = true; - } else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && collectedType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) { - // Virtual GPU's are the 3rd best choice - candidateDevices.clear(); - addDevice = true; - } - } - if (addDevice) { - candidateDevices.push_back(std::move(device)); - } - } - - for (auto itr = candidateDevices.begin(); itr != candidateDevices.end(); itr++) { - std::unique_ptr device = std::move(*itr); - m_devices[++m_topDeviceHandle] = std::move(device); - } -} - -VkInstance& KRContext::GetVulkanInstance() -{ - return m_vulkanInstance; -} diff --git a/kraken/KRContext.h b/kraken/KRContext.h index bddcef7..99fae99 100755 --- a/kraken/KRContext.h +++ b/kraken/KRContext.h @@ -45,6 +45,7 @@ #include "KRShaderManager.h" #include "KRSourceManager.h" #include "KRSurfaceManager.h" +#include "KRDeviceManager.h" #include "KRStreamer.h" #include "KRDevice.h" #include "KRSurface.h" @@ -111,6 +112,7 @@ public: KRShaderManager *getShaderManager(); KRSourceManager *getSourceManager(); KRSurfaceManager* getSurfaceManager(); + KRDeviceManager* getDeviceManager(); KRCamera *createCamera(int width, int height); @@ -159,11 +161,12 @@ public: static std::mutex g_SurfaceInfoMutex; static std::mutex g_DeviceInfoMutex; - + /* KRDevice& GetDeviceInfo(KrDeviceHandle handle); KRSurface& GetSurfaceInfo(KrSurfaceHandle handle); VkInstance& GetVulkanInstance(); KrSurfaceHandle GetBestDeviceForSurface(const VkSurfaceKHR& surface); + */ #if TARGET_OS_MAC static void attachToView(void *view); @@ -183,6 +186,7 @@ private: KRUnknownManager *m_pUnknownManager; KRShaderManager *m_pShaderManager; KRSourceManager *m_pSourceManager; + std::unique_ptr m_deviceManager; std::unique_ptr m_surfaceManager; KRResource** m_resourceMap; @@ -207,20 +211,12 @@ private: static void *s_log_callback_user_data; KRStreamer m_streamer; - VkInstance m_vulkanInstance; - - void createDeviceContexts(); - void createDevices(); - void destroyDeviceContexts(); unordered_multimap m_resources; std::unique_ptr m_presentationThread; - unordered_map> m_devices; - KrDeviceHandle m_topDeviceHandle; - unordered_map m_surfaceHandleMap; }; diff --git a/kraken/KRDeviceManager.cpp b/kraken/KRDeviceManager.cpp new file mode 100644 index 0000000..43fb7a6 --- /dev/null +++ b/kraken/KRDeviceManager.cpp @@ -0,0 +1,208 @@ +// +// KRDeviceManager.cpp +// Kraken Engine +// +// Copyright 2021 Kearwood Gilbert. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, are +// permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, this list +// of conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The views and conclusions contained in the software and documentation are those of the +// authors and should not be interpreted as representing official policies, either expressed +// or implied, of Kearwood Gilbert. +// + +#include "KRDeviceManager.h" + +KRDeviceManager::KRDeviceManager(KRContext& context) + : KRContextObject(context) + , m_vulkanInstance(VK_NULL_HANDLE) + , m_topDeviceHandle(0) +{ + +} + +KRDeviceManager::~KRDeviceManager() +{ + destroyDevices(); + if (m_vulkanInstance != VK_NULL_HANDLE) { + vkDestroyInstance(m_vulkanInstance, NULL); + m_vulkanInstance = VK_NULL_HANDLE; + } +} + +bool KRDeviceManager::haveVulkan() const +{ + return m_vulkanInstance != VK_NULL_HANDLE; +} + +bool KRDeviceManager::haveDevice() const +{ + return !m_devices.empty(); +} + +void +KRDeviceManager::destroyDevices() +{ + const std::lock_guard lock(KRContext::g_DeviceInfoMutex); + m_devices.clear(); +} + +void +KRDeviceManager::initialize() +{ + VkResult res = volkInitialize(); + if (res != VK_SUCCESS) { + destroyDevices(); + return; + } + + // initialize the VkApplicationInfo structure + VkApplicationInfo app_info = {}; + app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + app_info.pNext = NULL; + app_info.pApplicationName = "Test"; // TODO - Change Me! + app_info.applicationVersion = VK_MAKE_VERSION(0, 0, 1); + app_info.pEngineName = "Kraken Engine"; + app_info.engineVersion = VK_MAKE_VERSION(0, 1, 0); + app_info.apiVersion = VK_API_VERSION_1_0; + + // VK_KHR_surface and VK_KHR_win32_surface + + char* extensions[] = { + "VK_KHR_surface", +#ifdef WIN32 + "VK_KHR_win32_surface", +#endif + }; + + // initialize the VkInstanceCreateInfo structure + VkInstanceCreateInfo inst_info = {}; + inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + inst_info.pNext = NULL; + inst_info.flags = 0; + inst_info.pApplicationInfo = &app_info; +#ifdef WIN32 + inst_info.enabledExtensionCount = 2; +#else + inst_info.enabledExtensionCount = 1; +#endif + inst_info.ppEnabledExtensionNames = extensions; + inst_info.enabledLayerCount = 0; + inst_info.ppEnabledLayerNames = NULL; + + res = vkCreateInstance(&inst_info, NULL, &m_vulkanInstance); + if (res != VK_SUCCESS) { + destroyDevices(); + return; + } + + volkLoadInstance(m_vulkanInstance); + + createDevices(); +} + +void KRDeviceManager::createDevices() +{ + const std::lock_guard deviceLock(KRContext::g_DeviceInfoMutex); + if (m_devices.size() > 0) { + return; + } + uint32_t deviceCount = 0; + vkEnumeratePhysicalDevices(m_vulkanInstance, &deviceCount, nullptr); + if (deviceCount == 0) { + return; + } + + std::vector physicalDevices(deviceCount); + vkEnumeratePhysicalDevices(m_vulkanInstance, &deviceCount, physicalDevices.data()); + + const std::vector deviceExtensions = { + VK_KHR_SWAPCHAIN_EXTENSION_NAME + }; + + std::vector> candidateDevices; + + for (const VkPhysicalDevice& physicalDevice : physicalDevices) { + std::unique_ptr device = std::make_unique(physicalDevice); + if (!device->initialize(deviceExtensions)) { + continue; + } + + bool addDevice = false; + if (candidateDevices.empty()) { + addDevice = true; + } + else { + VkPhysicalDeviceType collectedType = candidateDevices[0]->m_deviceProperties.deviceType; + if (collectedType == device->m_deviceProperties.deviceType) { + addDevice = true; + } + else if (device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) { + // Discrete GPU's are always the best choice + candidateDevices.clear(); + addDevice = true; + } + else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) { + // Integrated GPU's are the second best choice + candidateDevices.clear(); + addDevice = true; + } + else if (collectedType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU && collectedType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU && device->m_deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) { + // Virtual GPU's are the 3rd best choice + candidateDevices.clear(); + addDevice = true; + } + } + if (addDevice) { + candidateDevices.push_back(std::move(device)); + } + } + + for (auto itr = candidateDevices.begin(); itr != candidateDevices.end(); itr++) { + std::unique_ptr device = std::move(*itr); + m_devices[++m_topDeviceHandle] = std::move(device); + } +} + +KRDevice& KRDeviceManager::getDeviceInfo(KrDeviceHandle handle) +{ + return *m_devices[handle]; +} + +VkInstance& KRDeviceManager::getVulkanInstance() +{ + return m_vulkanInstance; +} + +KrSurfaceHandle KRDeviceManager::getBestDeviceForSurface(const VkSurfaceKHR& surface) +{ + KrDeviceHandle deviceHandle = 0; + for (auto itr = m_devices.begin(); itr != m_devices.end(); itr++) { + KRDevice& device = *(*itr).second; + VkBool32 canPresent = false; + vkGetPhysicalDeviceSurfaceSupportKHR(device.m_device, device.m_graphicsFamilyQueueIndex, surface, &canPresent); + if (canPresent) { + deviceHandle = (*itr).first; + break; + } + } + return deviceHandle; +} \ No newline at end of file diff --git a/kraken/KRDeviceManager.h b/kraken/KRDeviceManager.h new file mode 100644 index 0000000..908bdbf --- /dev/null +++ b/kraken/KRDeviceManager.h @@ -0,0 +1,64 @@ +// +// KRDeviceManager.h +// Kraken Engine +// +// Copyright 2021 Kearwood Gilbert. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, are +// permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this list of +// conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, this list +// of conditions and the following disclaimer in the documentation and/or other materials +// provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY KEARWOOD GILBERT ''AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KEARWOOD GILBERT OR +// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// The views and conclusions contained in the software and documentation are those of the +// authors and should not be interpreted as representing official policies, either expressed +// or implied, of Kearwood Gilbert. +// + +#include "KREngine-common.h" + +#include "KRContext.h" +#include "KRDevice.h" + +#ifndef KRDEVICEMANAGER_H +#define KRDEVICEMANAGER_H + +class KRDeviceManager : KRContextObject +{ +public: + KRDeviceManager(KRContext& context); + ~KRDeviceManager(); + + void initialize(); + bool haveVulkan() const; + bool haveDevice() const; + + KRDevice& getDeviceInfo(KrDeviceHandle handle); + VkInstance& getVulkanInstance(); + KrSurfaceHandle getBestDeviceForSurface(const VkSurfaceKHR& surface); + +private: + unordered_map> m_devices; + KrDeviceHandle m_topDeviceHandle; + + void createDevices(); + void destroyDevices(); + VkInstance m_vulkanInstance; + +}; + +#endif // KRDEVICEMANAGER_H diff --git a/kraken/KRPipeline.cpp b/kraken/KRPipeline.cpp index e2d4da9..4503ec7 100644 --- a/kraken/KRPipeline.cpp +++ b/kraken/KRPipeline.cpp @@ -116,7 +116,7 @@ KRPipeline::KRPipeline(KRContext& context, KrDeviceHandle deviceHandle, VkFormat m_pipelineLayout = nullptr; m_graphicsPipeline = nullptr; m_renderPass = nullptr; - KRDevice& device = m_pContext->GetDeviceInfo(deviceHandle); + KRDevice& device = m_pContext->getDeviceManager()->getDeviceInfo(deviceHandle); strcpy(m_szKey, szKey); diff --git a/kraken/KRPresentationThread.cpp b/kraken/KRPresentationThread.cpp index d9c041e..f79c3ac 100644 --- a/kraken/KRPresentationThread.cpp +++ b/kraken/KRPresentationThread.cpp @@ -96,7 +96,7 @@ void KRPresentationThread::renderFrame() for (auto surfaceItr = surfaces.begin(); surfaceItr != surfaces.end(); surfaceItr++) { KRSurface& surface = *(*surfaceItr).second; - KRDevice& device = m_pContext->GetDeviceInfo(surface.m_deviceHandle); + KRDevice& device = m_pContext->getDeviceManager()->getDeviceInfo(surface.m_deviceHandle); uint32_t imageIndex = 0; vkAcquireNextImageKHR(device.m_logicalDevice, surface.m_swapChain, UINT64_MAX, surface.m_imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex); diff --git a/kraken/KRSurface.cpp b/kraken/KRSurface.cpp index 0ba2780..f09f087 100644 --- a/kraken/KRSurface.cpp +++ b/kraken/KRSurface.cpp @@ -62,16 +62,16 @@ KrResult KRSurface::initialize() createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; createInfo.hinstance = GetModuleHandle(nullptr); createInfo.hwnd = m_hWnd; - if (vkCreateWin32SurfaceKHR(m_pContext->GetVulkanInstance(), &createInfo, nullptr, &m_surface) != VK_SUCCESS) { + if (vkCreateWin32SurfaceKHR(m_pContext->getDeviceManager()->getVulkanInstance(), &createInfo, nullptr, &m_surface) != VK_SUCCESS) { return KR_ERROR_VULKAN; } - m_deviceHandle = m_pContext->GetBestDeviceForSurface(m_surface); + m_deviceHandle = m_pContext->getDeviceManager()->getBestDeviceForSurface(m_surface); if (m_deviceHandle == 0) { return KR_ERROR_NO_DEVICE; } - KRDevice* deviceInfo = &m_pContext->GetDeviceInfo(m_deviceHandle); + KRDevice* deviceInfo = &m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle); VkSemaphoreCreateInfo semaphoreInfo{}; semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; @@ -230,7 +230,7 @@ KrResult KRSurface::initialize() void KRSurface::destroy() { - KRDevice& deviceInfo = m_pContext->GetDeviceInfo(m_deviceHandle); + KRDevice& deviceInfo = m_pContext->getDeviceManager()->getDeviceInfo(m_deviceHandle); for (auto framebuffer : m_swapChainFramebuffers) { vkDestroyFramebuffer(deviceInfo.m_logicalDevice, framebuffer, nullptr); @@ -258,7 +258,7 @@ void KRSurface::destroy() } if (m_surface != VK_NULL_HANDLE) { - vkDestroySurfaceKHR(m_pContext->GetVulkanInstance(), m_surface, nullptr); + vkDestroySurfaceKHR(m_pContext->getDeviceManager()->getVulkanInstance(), m_surface, nullptr); m_surface = VK_NULL_HANDLE; }