XCEngine/new_editor/app/Scene/EditorSceneRuntime.cpp

#include "Scene/EditorSceneRuntime.h"

#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Scene/Scene.h>

namespace XCEngine::UI::Editor::App {

namespace {

using ::XCEngine::Components::GameObject;
using ::XCEngine::Components::Scene;

std::string ResolveGameObjectDisplayName(const GameObject& gameObject) {
    return gameObject.GetName().empty()
        ? std::string("GameObject")
        : gameObject.GetName();
}

} // namespace

bool EditorSceneRuntime::Initialize(const std::filesystem::path& projectRoot) {
    m_projectRoot = projectRoot;
    m_startupSceneResult = EnsureEditorStartupScene(projectRoot);
    RefreshScene();
    return m_startupSceneResult.ready;
}

void EditorSceneRuntime::RefreshScene() {
    if (!HasValidSelection()) {
        m_selectedGameObjectId.reset();
    }
}

void EditorSceneRuntime::EnsureSceneSelection() {
    if (HasValidSelection()) {
        return;
    }

    SelectFirstAvailableGameObject();
}

const EditorStartupSceneResult& EditorSceneRuntime::GetStartupResult() const {
    return m_startupSceneResult;
}

Scene* EditorSceneRuntime::GetActiveScene() const {
    return GetActiveEditorScene();
}

bool EditorSceneRuntime::HasSceneSelection() const {
    return HasValidSelection();
}

std::optional<GameObject::ID> EditorSceneRuntime::GetSelectedGameObjectId() const {
    return HasValidSelection() ? m_selectedGameObjectId : std::nullopt;
}

std::string EditorSceneRuntime::GetSelectedItemId() const {
    const std::optional<GameObject::ID> selectedId = GetSelectedGameObjectId();
    return selectedId.has_value()
        ? MakeEditorGameObjectItemId(selectedId.value())
        : std::string();
}

std::string EditorSceneRuntime::GetSelectedDisplayName() const {
    const GameObject* gameObject = GetSelectedGameObject();
    return gameObject != nullptr
        ? ResolveGameObjectDisplayName(*gameObject)
        : std::string();
}

const GameObject* EditorSceneRuntime::GetSelectedGameObject() const {
    if (!m_selectedGameObjectId.has_value()) {
        return nullptr;
    }

    Scene* scene = GetActiveScene();
    return scene != nullptr
        ? scene->FindByID(m_selectedGameObjectId.value())
        : nullptr;
}

bool EditorSceneRuntime::SetSelection(std::string_view itemId) {
    const std::optional<GameObject::ID> gameObjectId =
        ParseEditorGameObjectItemId(itemId);
    if (!gameObjectId.has_value()) {
        return false;
    }

    return SetSelection(gameObjectId.value());
}

bool EditorSceneRuntime::SetSelection(GameObject::ID id) {
    if (id == GameObject::INVALID_ID) {
        return false;
    }

    Scene* scene = GetActiveScene();
    if (scene == nullptr || scene->FindByID(id) == nullptr) {
        return false;
    }

    const bool changed =
        !m_selectedGameObjectId.has_value() ||
        m_selectedGameObjectId.value() != id;
    m_selectedGameObjectId = id;
    return changed;
}

void EditorSceneRuntime::ClearSelection() {
    m_selectedGameObjectId.reset();
}

GameObject* EditorSceneRuntime::FindGameObject(std::string_view itemId) const {
    return FindEditorGameObject(itemId);
}

bool EditorSceneRuntime::RenameGameObject(
    std::string_view itemId,
    std::string_view newName) {
    const bool renamed = RenameEditorGameObject(itemId, newName);
    RefreshScene();
    return renamed;
}

bool EditorSceneRuntime::DeleteGameObject(std::string_view itemId) {
    const bool deleted = DeleteEditorGameObject(itemId);
    RefreshScene();
    EnsureSceneSelection();
    return deleted;
}

std::string EditorSceneRuntime::DuplicateGameObject(std::string_view itemId) {
    const std::string duplicatedItemId = DuplicateEditorGameObject(itemId);
    if (!duplicatedItemId.empty()) {
        SetSelection(duplicatedItemId);
    } else {
        RefreshScene();
    }
    return duplicatedItemId;
}

bool EditorSceneRuntime::ReparentGameObject(
    std::string_view itemId,
    std::string_view parentItemId) {
    const bool reparented =
        ReparentEditorGameObject(itemId, parentItemId);
    RefreshScene();
    return reparented;
}

bool EditorSceneRuntime::MoveGameObjectToRoot(std::string_view itemId) {
    const bool moved = MoveEditorGameObjectToRoot(itemId);
    RefreshScene();
    return moved;
}

bool EditorSceneRuntime::HasValidSelection() const {
    return GetSelectedGameObject() != nullptr;
}

bool EditorSceneRuntime::SelectFirstAvailableGameObject() {
    Scene* scene = GetActiveScene();
    if (scene == nullptr) {
        m_selectedGameObjectId.reset();
        return false;
    }

    for (GameObject* root : scene->GetRootGameObjects()) {
        if (root == nullptr) {
            continue;
        }

        m_selectedGameObjectId = root->GetID();
        return true;
    }

    m_selectedGameObjectId.reset();
    return false;
}

} // namespace XCEngine::UI::Editor::App