SceneManager.cc

#include "SceneManager.hh"
 
#include "egg/core/ExpHeap.hh"
 
namespace EGG {
 
/*------------*
    Lifecycle
 *------------*/
 
SceneManager::SceneManager(SceneCreator *creator) {
    m_creator = creator;
    m_currentScene = nullptr;
}
 
SceneManager::~SceneManager() = default;
 
/*----------*
    Virtual
 *----------*/
 
void SceneManager::calc() {
    calcCurrentScene();
}
 
void SceneManager::calcCurrentScene() {
    if (!m_currentScene) {
        return;
    }
 
    m_currentScene->calc();
}
 
/*----------*
    Methods
 *----------*/
 
void SceneManager::createChildScene(int id, Scene *parent) {
    outgoingParentScene(parent);
    setNextSceneId(id);
    setupNextSceneId();
    createScene(id, parent);
}
 
void SceneManager::createScene(int id, Scene *parent) {
    Heap *parentHeap = parent ? parent->heap() : s_rootHeap;
 
    // We need to preserve the locked status to reinstate it later
    bool locked = parentHeap->tstDisableAllocation();
    if (locked) {
        parentHeap->enableAllocation();
    }
 
    ExpHeap *newHeap = ExpHeap::create(-1, parentHeap, s_heapOptionFlg);
    s_heapForCreateScene = newHeap;
 
    if (locked) {
        parentHeap->disableAllocation();
    }
 
    newHeap->becomeCurrentHeap();
    newHeap->setName("DefaultSceneHeap");
 
    Scene *newScene = m_creator->create(id);
 
    if (parent) {
        parent->setChild(newScene);
    }
 
    m_currentScene = newScene;
    newScene->setId(id);
    newScene->setParent(parent);
    newScene->setSceneMgr(this);
    newScene->enter();
}
 
void SceneManager::destroyScene(Scene *scene) {
    scene->exit();
    if (scene->child()) {
        destroyScene(scene->child());
    }
 
    Scene *parent = scene->parent();
    m_creator->destroy(scene->id());
    m_currentScene = nullptr;
 
    if (parent) {
        parent->setChild(nullptr);
        m_currentScene = parent;
    }
 
    scene->heap()->destroy();
    Heap *parentHeap = parent ? parent->heap() : s_rootHeap;
    parentHeap->becomeCurrentHeap();
}
 
void SceneManager::changeScene(int nextSceneId) {
    while (m_currentScene) {
        destroyCurrentSceneNoIncoming(true);
    }
 
    changeSiblingScene(nextSceneId);
}
 
void SceneManager::changeSiblingScene(int nextSceneId) {
    setNextSceneId(nextSceneId);
    changeSiblingScene();
}
 
void SceneManager::changeSiblingScene() {
    Scene *parentScene = m_currentScene ? m_currentScene->parent() : nullptr;
 
    if (m_currentScene) {
        destroyScene(m_currentScene);
        m_currentScene = nullptr;
    }
 
    int nextSceneId = m_nextSceneId;
    setupNextSceneId();
    createScene(nextSceneId, parentScene);
}
 
void SceneManager::incomingCurrentScene() {
    if (!m_currentScene) {
        return;
    }
 
    m_currentScene->incoming_childDestroy();
}
 
void SceneManager::outgoingParentScene(Scene *parent) {
    parent->outgoing_childCreate();
}
 
void SceneManager::reinitCurrentScene() {
    if (!m_currentScene) {
        return;
    }
 
    m_currentScene->reinit();
}
 
bool SceneManager::destroyCurrentSceneNoIncoming(bool destroyRootIfNoParent) {
    if (!m_currentScene) {
        return false;
    }
 
    Scene *parent = m_currentScene->parent();
    if (parent) {
        destroyScene(parent->child());
        setNextSceneId(parent->id());
        setupNextSceneId();
        return true;
    } else {
        if (destroyRootIfNoParent) {
            destroyScene(m_currentScene);
            setNextSceneId(-1);
            setupNextSceneId();
        }
        return false;
    }
}
 
bool SceneManager::destroyToSelectSceneId(int id) {
    Scene *parent = findParentScene(id);
    if (!parent) {
        return false;
    }
 
    while (parent->id() != currentSceneId()) {
        destroyCurrentSceneNoIncoming(false);
    }
    incomingCurrentScene();
    return true;
}
 
Scene *SceneManager::findParentScene(int id) const {
    Scene *scene = m_currentScene->parent();
    for (; scene; scene = scene->parent()) {
        if (scene->id() == id) {
            break;
        }
    }
 
    return scene;
}
 
void SceneManager::setupNextSceneId() {
    m_prevSceneId = m_currentSceneId;
    m_currentSceneId = m_nextSceneId;
    m_nextSceneId = -1;
}
 
Heap *SceneManager::s_heapForCreateScene = nullptr;
u16 SceneManager::s_heapOptionFlg = 2;
 
Heap *SceneManager::s_rootHeap = nullptr;
 
} // namespace EGG