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

Session owned managers are now using std::unique_ptr

Browse Source
This commit is contained in:
Kearwood Gilbert
2021-08-17 01:22:18 -07:00
parent 5d0a4bc9d2
commit fc55a5d490
7 changed files with 84 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
kraken/KRAudioManager.cpp
View File

@@ -1185,15 +1185,24 @@ void KRAudioManager::cleanupAudio()
KRAudioManager::~KRAudioManager()
{
for(unordered_map<std::string, KRAudioSample *>::iterator name_itr=m_sounds.begin(); name_itr != m_sounds.end(); name_itr++) {
// 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;
for (std::vector<KRDataBlock*>::iterator itr = m_bufferPoolIdle.begin(); itr != m_bufferPoolIdle.end(); itr++) {
delete* itr;
}
m_bufferPoolIdle.clear();
}
void KRAudioManager::makeCurrentContext()

1
kraken/KRAudioManager.h
View File

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

120
kraken/KRContext.cpp
View File

@@ -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_pPipelineManager = new KRPipelineManager(*this);
m_pTextureManager = new KRTextureManager(*this);
m_pMaterialManager = new KRMaterialManager(*this, m_pTextureManager, m_pPipelineManager);
m_pMeshManager = new KRMeshManager(*this);
m_pSceneManager = new KRSceneManager(*this);
m_pAnimationManager = new KRAnimationManager(*this);
m_pAnimationCurveManager = new KRAnimationCurveManager(*this);
m_pSoundManager = new KRAudioManager(*this);
m_pUnknownManager = new KRUnknownManager(*this);
m_pShaderManager = new KRShaderManager(*this);
m_pSourceManager = new KRSourceManager(*this);
m_pBundleManager = std::make_unique<KRBundleManager>(*this);
m_pPipelineManager = std::make_unique<KRPipelineManager>(*this);
m_pTextureManager = std::make_unique<KRTextureManager>(*this);
m_pMaterialManager = std::make_unique<KRMaterialManager>(*this, m_pTextureManager.get(), m_pPipelineManager.get());
m_pMeshManager = std::make_unique<KRMeshManager>(*this);
m_pSceneManager = std::make_unique<KRSceneManager>(*this);
m_pAnimationManager = std::make_unique<KRAnimationManager>(*this);
m_pAnimationCurveManager = std::make_unique<KRAnimationCurveManager>(*this);
m_pSoundManager = std::make_unique<KRAudioManager>(*this);
m_pUnknownManager = std::make_unique<KRUnknownManager>(*this);
m_pShaderManager = std::make_unique<KRShaderManager>(*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) {
delete m_pSceneManager;
m_pSceneManager = NULL;
}
if(m_pMeshManager) {
delete m_pMeshManager;
m_pMeshManager = NULL;
}
if(m_pTextureManager) {
delete m_pTextureManager;
m_pTextureManager = NULL;
}
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_pSceneManager.reset();
m_pMeshManager.reset();
m_pMaterialManager.reset();
m_pTextureManager->destroy();
m_pTextureManager.reset();
m_pPipelineManager.reset();
m_pAnimationManager.reset();
m_pAnimationCurveManager.reset();
m_pSoundManager->destroy();
m_pSoundManager.reset();
m_pSourceManager.reset();
m_pUnknownManager.reset();
m_pShaderManager.reset();
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()
{

24
kraken/KRContext.h
View File

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

1
kraken/KRDeviceManager.cpp
View File

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

11
kraken/KRTextureManager.cpp
View File

@@ -53,10 +53,17 @@ KRTextureManager::KRTextureManager(KRContext &context) : KRResourceManager(conte
_clearGLState();
}
KRTextureManager::~KRTextureManager() {
for(unordered_map<std::string, KRTexture *>::iterator itr = m_textures.begin(); itr != m_textures.end(); ++itr){
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()

1
kraken/KRTextureManager.h
View File

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