Session owned managers are now using std::unique_ptr

kraken/KRAudioManager.cpp

@@ -1184,16 +1184,25 @@ void KRAudioManager::cleanupAudio()
 }
 
 KRAudioManager::~KRAudioManager()
+{
+  // Must call destroy first
+  assert(m_sounds.empty());
+  assert(m_bufferPoolIdle.empty());
+}
+
+void KRAudioManager::destroy()
 {
   for (unordered_map<std::string, KRAudioSample*>::iterator name_itr = m_sounds.begin(); name_itr != m_sounds.end(); name_itr++) {
     delete (*name_itr).second;
   }
+  m_sounds.clear();
 
   cleanupAudio();
 
   for (std::vector<KRDataBlock*>::iterator itr = m_bufferPoolIdle.begin(); itr != m_bufferPoolIdle.end(); itr++) {
     delete* itr;
   }
+  m_bufferPoolIdle.clear();
 }
 
 void KRAudioManager::makeCurrentContext()

kraken/KRAudioManager.h

@@ -96,6 +96,7 @@ class KRAudioManager : public KRResourceManager {
 public:
     KRAudioManager(KRContext &context);
     virtual ~KRAudioManager();
+    void destroy();
 
     virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
     virtual KRResource* getResource(const std::string& name, const std::string& extension) override;

kraken/KRContext.cpp

@@ -99,18 +99,18 @@ KRContext::KRContext(const KrInitializeInfo* initializeInfo)
     m_last_fully_streamed_frame = 0;
     m_absolute_time = 0.0f;
     
-    m_pBundleManager = new KRBundleManager(*this);
+    m_pBundleManager = std::make_unique<KRBundleManager>(*this);
-    m_pPipelineManager = new KRPipelineManager(*this);
+    m_pPipelineManager = std::make_unique<KRPipelineManager>(*this);
-    m_pTextureManager = new KRTextureManager(*this);
+    m_pTextureManager = std::make_unique<KRTextureManager>(*this);
-    m_pMaterialManager = new KRMaterialManager(*this, m_pTextureManager, m_pPipelineManager);
+    m_pMaterialManager = std::make_unique<KRMaterialManager>(*this, m_pTextureManager.get(), m_pPipelineManager.get());
-    m_pMeshManager = new KRMeshManager(*this);
+    m_pMeshManager = std::make_unique<KRMeshManager>(*this);
-    m_pSceneManager = new KRSceneManager(*this);
+    m_pSceneManager = std::make_unique<KRSceneManager>(*this);
-    m_pAnimationManager = new KRAnimationManager(*this);
+    m_pAnimationManager = std::make_unique<KRAnimationManager>(*this);
-    m_pAnimationCurveManager = new KRAnimationCurveManager(*this);
+    m_pAnimationCurveManager = std::make_unique<KRAnimationCurveManager>(*this);
-    m_pSoundManager = new KRAudioManager(*this);
+    m_pSoundManager = std::make_unique<KRAudioManager>(*this);
-    m_pUnknownManager = new KRUnknownManager(*this);
+    m_pUnknownManager = std::make_unique<KRUnknownManager>(*this);
-    m_pShaderManager = new KRShaderManager(*this);
+    m_pShaderManager = std::make_unique<KRShaderManager>(*this);
-    m_pSourceManager = new KRSourceManager(*this);
+    m_pSourceManager = std::make_unique<KRSourceManager>(*this);
     m_deviceManager = std::make_unique<KRDeviceManager>(*this);
     m_surfaceManager = std::make_unique<KRSurfaceManager>(*this);
     m_streamingEnabled = true;
@@ -138,64 +138,26 @@ KRContext::KRContext(const KrInitializeInfo* initializeInfo)
 
 KRContext::~KRContext() {
     m_presentationThread->stop();
-    if(m_pSceneManager) {
+    m_pSceneManager.reset();
-        delete m_pSceneManager;
+    m_pMeshManager.reset();
-        m_pSceneManager = NULL;
+    m_pMaterialManager.reset();
-    }
+    m_pTextureManager->destroy();
-    
+    m_pTextureManager.reset();
-    if(m_pMeshManager) {
+    m_pPipelineManager.reset();
-        delete m_pMeshManager;
+    m_pAnimationManager.reset();
-        m_pMeshManager = NULL;
+    m_pAnimationCurveManager.reset();
-    }
+    m_pSoundManager->destroy();
-    
+    m_pSoundManager.reset();
-    if(m_pTextureManager) {
+    m_pSourceManager.reset();
-        delete m_pTextureManager;
+    m_pUnknownManager.reset();
-        m_pTextureManager = NULL;
+    m_pShaderManager.reset();
-    }
-    
-    if(m_pMaterialManager) {
-        delete m_pMaterialManager;
-        m_pMaterialManager = NULL;
-    }
-    
-    if(m_pPipelineManager) {
-        delete m_pPipelineManager;
-        m_pPipelineManager = NULL;
-    }
-    
-    if(m_pAnimationManager) {
-        delete m_pAnimationManager;
-        m_pAnimationManager = NULL;
-    }
-    
-    if(m_pAnimationCurveManager) {
-        delete m_pAnimationCurveManager;
-        m_pAnimationCurveManager = NULL;
-    }
-    
-    if(m_pSoundManager) {
-        delete m_pSoundManager;
-        m_pSoundManager = NULL;
-    }
-
-    if(m_pSourceManager) {
-        delete m_pSourceManager;
-        m_pSourceManager = NULL;
-    }
-
-    if(m_pUnknownManager) {
-        delete m_pUnknownManager;
-        m_pUnknownManager = NULL;
-    }
-    
-    // The bundles must be destroyed last, as the other objects may be using mmap'ed data from bundles
-    if(m_pBundleManager) {
-        delete m_pBundleManager;
-        m_pBundleManager = NULL;
-    }
     m_surfaceManager.reset();
     m_deviceManager.reset();
     
+    // The bundles must be destroyed last, as the other objects may be using mmap'ed data from bundles
+    m_pBundleManager.reset();
+
+ 
     if (m_resourceMap) {
         delete m_resourceMap;
         m_resourceMap = NULL;
@@ -229,37 +191,37 @@ void KRContext::Log(log_level level, const std::string message_format, ...)
 }
 
 KRBundleManager *KRContext::getBundleManager() {
-    return m_pBundleManager;
+    return m_pBundleManager.get();
 }
 KRSceneManager *KRContext::getSceneManager() {
-    return m_pSceneManager;
+    return m_pSceneManager.get();
 }
 KRTextureManager *KRContext::getTextureManager() {
-    return m_pTextureManager;
+    return m_pTextureManager.get();
 }
 KRMaterialManager *KRContext::getMaterialManager() {
-    return m_pMaterialManager;
+    return m_pMaterialManager.get();
 }
 KRPipelineManager *KRContext::getPipelineManager() {
-    return m_pPipelineManager;
+    return m_pPipelineManager.get();
 }
 KRMeshManager *KRContext::getMeshManager() {
-    return m_pMeshManager;
+    return m_pMeshManager.get();
 }
 KRAnimationManager *KRContext::getAnimationManager() {
-    return m_pAnimationManager;
+    return m_pAnimationManager.get();
 }
 KRAnimationCurveManager *KRContext::getAnimationCurveManager() {
-    return m_pAnimationCurveManager;
+    return m_pAnimationCurveManager.get();
 }
 KRAudioManager *KRContext::getAudioManager() {
-    return m_pSoundManager;
+    return m_pSoundManager.get();
 }
 KRShaderManager *KRContext::getShaderManager() {
-    return m_pShaderManager;
+    return m_pShaderManager.get();
 }
 KRSourceManager *KRContext::getSourceManager() {
-    return m_pSourceManager;
+    return m_pSourceManager.get();
 }
 KRSurfaceManager* KRContext::getSurfaceManager() {
   return m_surfaceManager.get();
@@ -268,7 +230,7 @@ KRDeviceManager* KRContext::getDeviceManager() {
   return m_deviceManager.get();
 }
 KRUnknownManager *KRContext::getUnknownManager() {
-    return m_pUnknownManager;
+    return m_pUnknownManager.get();
 }
 std::vector<KRResource *> KRContext::getResources()
 {

kraken/KRContext.h

@@ -168,18 +168,18 @@ public:
     void addResource(KRResource* resource, const std::string& name);
     void removeResource(KRResource* resource);
 private:
-    KRBundleManager *m_pBundleManager;
+    std::unique_ptr<KRBundleManager> m_pBundleManager;
-    KRSceneManager *m_pSceneManager;
+    std::unique_ptr<KRSceneManager> m_pSceneManager;
-    KRTextureManager *m_pTextureManager;
+    std::unique_ptr<KRTextureManager> m_pTextureManager;
-    KRMaterialManager *m_pMaterialManager;
+    std::unique_ptr<KRMaterialManager> m_pMaterialManager;
-    KRPipelineManager *m_pPipelineManager;
+    std::unique_ptr<KRPipelineManager> m_pPipelineManager;
-    KRMeshManager *m_pMeshManager;
+    std::unique_ptr<KRMeshManager> m_pMeshManager;
-    KRAnimationManager *m_pAnimationManager;
+    std::unique_ptr<KRAnimationManager> m_pAnimationManager;
-    KRAnimationCurveManager *m_pAnimationCurveManager;
+    std::unique_ptr<KRAnimationCurveManager> m_pAnimationCurveManager;
-    KRAudioManager *m_pSoundManager;
+    std::unique_ptr<KRAudioManager> m_pSoundManager;
-    KRUnknownManager *m_pUnknownManager;
+    std::unique_ptr<KRUnknownManager> m_pUnknownManager;
-    KRShaderManager *m_pShaderManager;
+    std::unique_ptr<KRShaderManager> m_pShaderManager;
-    KRSourceManager *m_pSourceManager;
+    std::unique_ptr<KRSourceManager> m_pSourceManager;
     std::unique_ptr<KRDeviceManager> m_deviceManager;
     std::unique_ptr<KRSurfaceManager> m_surfaceManager;
 

kraken/KRDeviceManager.cpp

@@ -42,6 +42,7 @@ KRDeviceManager::KRDeviceManager(KRContext& context)
 KRDeviceManager::~KRDeviceManager()
 {
   destroyDevices();
+  
   if (m_vulkanInstance != VK_NULL_HANDLE) {
     vkDestroyInstance(m_vulkanInstance, NULL);
     m_vulkanInstance = VK_NULL_HANDLE;

kraken/KRTextureManager.cpp

@@ -53,10 +53,17 @@ KRTextureManager::KRTextureManager(KRContext &context) : KRResourceManager(conte
     _clearGLState();
 }
 
-KRTextureManager::~KRTextureManager() {
+void KRTextureManager::destroy()
+{
   for (unordered_map<std::string, KRTexture*>::iterator itr = m_textures.begin(); itr != m_textures.end(); ++itr) {
     delete (*itr).second;
   }
+  m_textures.clear();
+}
+
+KRTextureManager::~KRTextureManager() {
+  // Must call destroy() first
+  assert(m_textures.empty());
 }
 
 void KRTextureManager::_clearGLState()

kraken/KRTextureManager.h

@@ -47,6 +47,7 @@ class KRTextureManager : public KRResourceManager {
 public:
     KRTextureManager(KRContext &context);
     virtual ~KRTextureManager();
+    void destroy();
 
     virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override;
     virtual KRResource* getResource(const std::string& name, const std::string& extension) override;