#include "Project.h"

#include "EditorWorld.h"

#include "AssetDatabase.h"

#include "BuildSystem.h"

#include "UI/ProjectSettingUI.h"

#include "DragDropHelper.hpp"

#include "Core/FileSystem.h"

#include "Core/GarbageCollection.h"

#include "Core/ModuleLoader.h"

#include "Render/Renderer.h"

#include "Game/GameObject.h"

#include "Game/GameManager.h"

#include "Game/Prefab.h"

#include "Game/World.h"

#include "Game/ScriptableObject.h"

namespace sh::editor

{

Project::Project(render::Renderer& renderer, game::ImGUImpl& gui) :

renderer(renderer), gui(gui),

rootPath(std::filesystem::current_path()),

assetDatabase(*AssetDatabase::GetInstance()),

engineDirRegex("set\\(ENGINE_DIR .*?\\)", std::regex::optimize)

{

exePath = core::FileSystem::GetExecutableDirectory();

onAssetImportedListener.SetCallback(

[this](core::SObject* objPtr)

{

if (objPtr == nullptr)

return;

if (objPtr->GetType().IsChildOf(game::ScriptableObject::GetStaticType()))

loadedScriptableObjects.insert(objPtr);

loadedAssets.push_back(objPtr);

}

);

LoadLatestProjectPath();

}

Project::~Project()

{

commandHistory.Clear();

for (auto objPtr : loadedAssets)

{

if (objPtr == nullptr)

continue;

objPtr->Destroy();

}

core::GarbageCollection::GetInstance()->Collect();

core::GarbageCollection::GetInstance()->DestroyPendingKillObjs();

core::GarbageCollection::GetInstance()->Collect(); // 남아 있는 GCObject들도 제거 해줘야 해서 한번 더 호출

core::GarbageCollection::GetInstance()->DestroyPendingKillObjs();

componentLoader.UnloadPlugin();

setting.Save(rootPath / "ProjectSetting.json");

assetDatabase.SaveDatabase(libraryPath / "AssetDB.json");

loadedAssets.clear();

}

SH_EDITOR_API void Project::Update()

{

}

SH_EDITOR_API void Project::Render()

{

static ImGuiWindowFlags style =

ImGuiWindowFlags_::ImGuiWindowFlags_NoBringToFrontOnFocus;

ImGui::PushStyleVar(ImGuiStyleVar_::ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));

ImGui::Begin("Project", nullptr, style);

float h = ImGui::GetWindowContentRegionMax().y - 50;

ImGui::BeginChild("Explorer", ImVec2{ 0.f, h }, ImGuiChildFlags_::ImGuiChildFlags_None, ImGuiWindowFlags_::ImGuiWindowFlags_AlwaysVerticalScrollbar);

const ImVec2 contentMin = ImGui::GetWindowContentRegionMin();

const ImVec2 contentMax = ImGui::GetWindowContentRegionMax();

const ImVec2 windowPos = ImGui::GetWindowPos(); // 스크린 좌표

const ImVec2 spaceMin = ImVec2(windowPos.x + contentMin.x, windowPos.y + contentMin.y);

const ImVec2 spaceMax = ImVec2(windowPos.x + contentMax.x, windowPos.y + contentMax.y);

const float availableWidth = ImGui::GetContentRegionAvail().x;

const ImVec2 emptySize = ImVec2(spaceMax.x - spaceMin.x, spaceMax.y - spaceMin.y);

const ImVec2 cursorPos = ImGui::GetCursorPos();

ImGui::SetNextItemAllowOverlap();

if (ImGui::InvisibleButton("ProjectEmptySpace", emptySize))

{

projectExplorer.ResetSelected();

for (auto& [uuid, worldPtr] : game::GameManager::GetInstance()->GetWorlds())

{

auto& world = static_cast<EditorWorld&>(*worldPtr);

world.ClearSelectedObjects();

}

}

// 프리팹 드래그

if (ImGui::BeginDragDropTarget())

{

if (game::GameObject* objPtr = dragdrop::AcceptAsset<game::GameObject>())

{

if (core::IsValid(objPtr))

{

auto prefab = game::Prefab::CreatePrefab(*objPtr);

const auto exportDir = projectExplorer.GetCurrentPath() / fmt::format("{}.prefab", prefab->GetName().ToString());

if (std::filesystem::exists(exportDir))

{

auto opt = assetDatabase.GetAssetUUID(exportDir);

assert(opt.has_value());

if (opt.has_value())

{

auto sobjPtr = core::SObjectManager::GetInstance()->GetSObject(opt.value());

auto oldPrefabPtr = static_cast<game::Prefab*>(sobjPtr);

*oldPrefabPtr = std::move(*prefab);

assetDatabase.SetDirty(oldPrefabPtr);

assetDatabase.SaveAllAssets();

}

}

else

{

assetDatabase.CreateAsset(exportDir, *prefab);

projectExplorer.Refresh();

}

}

}

ImGui::EndDragDropTarget();

}

ImGui::SetCursorPos(cursorPos);

projectExplorer.Render(availableWidth);

ImGui::EndChild();

ImGui::PopStyleVar();

RenderNameBar();

ImGui::End();

if (bSettingUI)

ProjectSettingUI::RenderUI(setting, rootPath, bSettingUI);

}

SH_EDITOR_API void Project::CreateNewProject(const std::filesystem::path& dir)

{

if (IsProjectPath(dir))

{

SH_ERROR_FORMAT("{} is already exist!", dir.u8string());

return;

}

if (!std::filesystem::create_directory(dir))

{

SH_INFO_FORMAT("Can't create directory: {}", dir.u8string());

}

CopyProjectTemplate(dir);

OpenProject(dir);

}

SH_EDITOR_API void Project::OpenProject(const std::filesystem::path& dir)

{

commandHistory.Clear();

rootPath = dir;

assetPath = rootPath / "Assets";

binaryPath = rootPath / "bin";

libraryPath = rootPath / "Library";

tempPath = rootPath / "temp";

const auto settingPath = rootPath / "ProjectSetting.json";

if (!IsProjectPath(dir))

{

SH_ERROR_FORMAT("Wrong project directory: {}", dir.u8string());

return;

}

isOpen = true;

projectExplorer.SetRoot(assetPath);

projectExplorer.Refresh();

LoadEditorPlugin();

assetDatabase.Init(rootPath, *renderer.GetContext(), gui);

assetDatabase.onAssetImported.Register(onAssetImportedListener);

assetDatabase.LoadDatabase(libraryPath / "AssetDB.json");

assetDatabase.LoadAllAssets(assetPath, true, false);

setting.Load(settingPath);

SaveLatestProjectPath(dir);

ChangeSourcePath(dir); // CMakeLists.txt의 엔진 경로 바꾸는 함수

if (!setting.lastWorldUUID.IsEmpty())

{

auto assetInfoPtr = assetDatabase.GetAssetPath(setting.lastWorldUUID);

if (assetInfoPtr != nullptr)

LoadWorld(assetInfoPtr->originalPath);

}

else

NewWorld("New World");

}

SH_EDITOR_API void Project::NewWorld(const std::string& name)

{

commandHistory.Clear();

auto& gameManager = *game::GameManager::GetInstance();

editor::EditorWorld* newWorld = core::SObject::Create<editor::EditorWorld>(*this);

gameManager.LoadWorld(newWorld->GetUUID());

}

SH_EDITOR_API void Project::SaveWorld()

{

for (auto& [uuid, worldPtr] : game::GameManager::GetInstance()->GetWorlds())

{

worldPtr->SaveWorldPoint(worldPtr->Serialize());

assetDatabase.SetDirty(worldPtr);

}

assetDatabase.SaveAllAssets();

}

SH_EDITOR_API void Project::SaveAsWorld(const std::filesystem::path& worldAssetPath)

{

game::World* currentWorld = game::GameManager::GetInstance()->GetMainWorld();

if (!core::IsValid(currentWorld))

return;

currentWorld->ReallocateUUIDS();

std::ofstream os{ worldAssetPath };

os << std::setw(4) << currentWorld->Serialize();

os.close();

}

SH_EDITOR_API void Project::LoadWorld(const std::filesystem::path& worldAssetPath)

{

auto uuidOpt = assetDatabase.GetAssetUUID(worldAssetPath);

if (!uuidOpt.has_value())

return;

core::SObject* obj = core::SObjectManager::GetInstance()->GetSObject(uuidOpt.value());

if (obj == nullptr)

return;

game::World* world = core::reflection::Cast<game::World>(obj);

if (world == nullptr)

return;

auto& gameManager = *game::GameManager::GetInstance();

gameManager.LoadWorld(world->GetUUID());

commandHistory.Clear();

setting.lastWorldUUID = world->GetUUID();

}

SH_EDITOR_API auto Project::IsProjectOpen() const -> bool

{

return isOpen;

}

SH_EDITOR_API void Project::ReloadModule()

{

static bool bReloading = false;

if (bReloading)

return;

bReloading = true;

game::GameManager::GetInstance()->AddAterUpdateTask(

[this]()

{

std::vector<core::UUID> scriptableObjects;

if (componentLoader.IsLoaded())

{

// 1. 월드 상태 저장 후 유저 컴포넌트들을 모두 제거 후 메모리에서 해제

for (auto& [uuid, worldPtr] : game::GameManager::GetInstance()->GetWorlds())

{

if (worldPtr == nullptr)

continue;

worldPtr->SaveWorldPoint(worldPtr->Serialize(), "temp");

for (auto obj : worldPtr->GetGameObjects())

{

for (auto component : obj->GetComponents())

{

if (component == nullptr)

continue;

for (auto& userComponent : componentLoader.GetLoadedComponents())

{

if (component->GetType() == *userComponent.type)

component->Destroy();

}

}

}

}

// 2. 유저 ScriptableObject들도 모두 제거

for (auto objPtr : loadedScriptableObjects)

{

if (objPtr == nullptr)

continue;

scriptableObjects.push_back(objPtr->GetUUID());

objPtr->Destroy();

}

loadedScriptableObjects.clear();

core::GarbageCollection::GetInstance()->Collect();

core::GarbageCollection::GetInstance()->DestroyPendingKillObjs();

core::GarbageCollection::GetInstance()->Collect(); // 남아 있는 GCObject들도 제거해 줘야 해서 한번 더 호출

core::GarbageCollection::GetInstance()->DestroyPendingKillObjs();

// 3. 플러그인 언로드

componentLoader.UnloadPlugin();

}

// 4. 플러그인 로드 후 복원

LoadEditorPlugin();

for (const auto& uuid : scriptableObjects)

{

const auto assetInfo = assetDatabase.GetAssetPath(uuid);

if (assetInfo == nullptr)

continue;

assetDatabase.ImportAsset(assetInfo->originalPath);

}

for (auto& [uuid, worldPtr] : game::GameManager::GetInstance()->GetWorlds())

{

worldPtr->LoadWorldPoint("temp");

worldPtr->ClearWorldPoint("temp");

}

bReloading = false;

}

);

}

SH_EDITOR_API void Project::OpenSettingUI()

{

bSettingUI = true;

}

SH_EDITOR_API void Project::Build()

{

BuildSystem builder{};

if (!setting.startingWorldUUID.IsEmpty())

{

builder.Build(*this, binaryPath);

}

else

SH_ERROR("Set the starting world first!");

}

SH_EDITOR_API auto Project::IsProjectPath(const std::filesystem::path& path) -> bool

{

const auto assetPath = path / "Assets";

const auto settingPath = path / "ProjectSetting.json";

if (!std::filesystem::exists(assetPath) || !std::filesystem::exists(settingPath))

return false;

return true;

}

SH_EDITOR_API auto Project::GetLatestProjectPath() -> std::filesystem::path

{

return LoadLatestProjectPath();

}

void Project::RenderNameBar()

{

ImGui::PushStyleColor(ImGuiCol_::ImGuiCol_ChildBg, ImVec4{ 0.2, 0.2, 0.2, 1 });

ImGui::BeginChild("Namebar", ImVec2{ 0, 0 });

ImGui::SetCursorPosX(5.0f);

if (!projectExplorer.GetSelected().empty())

ImGui::Text(projectExplorer.GetSelected().back().u8string().c_str());

ImGui::EndChild();

ImGui::PopStyleColor();

}

void Project::CopyProjectTemplate(const std::filesystem::path& targetDir)

{

const std::filesystem::path projectTemplate{ exePath / "ProjectTemplate" };

core::FileSystem::CopyAllFiles(projectTemplate, targetDir);

ChangeSourcePath(targetDir);

}

void Project::LoadEditorPlugin()

{

const auto pluginPath = game::ComponentLoader::CreatePluginPath(binaryPath / "ShellEngineUser");

const auto editorPluginPath = game::ComponentLoader::CreatePluginPath(binaryPath / "ShellEngineUserEditor");

if (!std::filesystem::exists(tempPath))

{

std::error_code ec;

if (!std::filesystem::create_directory(tempPath, ec))

{

SH_ERROR_FORMAT("Failed to create temp path({}): {}", tempPath.u8string(), ec.message());

return;

}

}

const auto tempPluginPath = game::ComponentLoader::CreatePluginPath(tempPath / "ShellEngineUser");

const auto tempEditorPluginPath = game::ComponentLoader::CreatePluginPath(tempPath / "ShellEngineUserEditor");

const bool bPluginExist = std::filesystem::exists(pluginPath);

const bool bEditorPluginExist = std::filesystem::exists(editorPluginPath);

if (!bPluginExist && !bEditorPluginExist)

{

SH_ERROR("Not found plugin!");

return;

}

if (bPluginExist)

{

std::error_code ec;

if (!std::filesystem::copy_file(pluginPath, tempPluginPath, std::filesystem::copy_options::overwrite_existing, ec))

{

SH_ERROR_FORMAT("Failed to copy plugin: {}", ec.message());

return;

}

}

if (bEditorPluginExist)

{

std::error_code ec;

if (!std::filesystem::copy_file(editorPluginPath, tempEditorPluginPath, std::filesystem::copy_options::overwrite_existing), ec)

{

SH_ERROR_FORMAT("Failed to copy plugin: {}", ec.message());

return;

}

componentLoader.LoadPlugin(tempEditorPluginPath);

return;

}

componentLoader.LoadPlugin(tempPluginPath);

}

void Project::ChangeSourcePath(const std::filesystem::path& projectRootPath)

{

auto cmake = core::FileSystem::LoadText(projectRootPath / "CMakeLists.txt");

if (cmake.has_value())

{

std::string cmakeStr = std::move(cmake.value());

const std::string replacement = fmt::format("set(ENGINE_DIR {})", exePath.generic_u8string());

cmakeStr = std::regex_replace(cmakeStr, engineDirRegex, replacement);

core::FileSystem::SaveText(cmakeStr, projectRootPath / "CMakeLists.txt");

}

}

void Project::SaveLatestProjectPath(const std::filesystem::path& path)

{

if (path.empty())

return;

core::FileSystem::SaveText(path.u8string(), "latestProjectPath");

}

auto Project::LoadLatestProjectPath() -> std::filesystem::path

{

auto opt = core::FileSystem::LoadText("latestProjectPath");

if (opt.has_value())

return std::filesystem::u8path(opt.value());

else

return {};

}

}//namespace