#include "Game/PCH.h"

#include "Project.h"

#include "EditorWorld.h"

#include "EditorResource.h"

#include "AssetDatabase.h"

#include "Game/ModelLoader.h"

#include "Core/FileSystem.h"

#include "Core/FileLoader.h"

namespace sh::editor

{

bool Project::bInitResource = false;

Project::Project(game::ImGUImpl& imgui, EditorWorld& world) :

UI(imgui), world(world),

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

currentPath(rootPath)

{

invisibleExtensions.push_back(".meta");

InitResources();

GetAllFiles(currentPath);

}

void Project::InitResources()

{

if (bInitResource)

return;

bInitResource = true;

auto resource = EditorResource::GetInstance();

folderIcon = resource->GetIcon(EditorResource::Icon::Folder);

fileIcon = resource->GetIcon(EditorResource::Icon::File);

meshIcon = resource->GetIcon(EditorResource::Icon::Mesh);

}

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

{

foldersPath.clear();

filesPath.clear();

for (const auto& entry : std::filesystem::directory_iterator(path))

{

if (std::filesystem::is_directory(entry.path()))

foldersPath.push_back(entry.path());

else if (std::filesystem::is_regular_file(entry.path()))

filesPath.push_back(entry.path());

}

std::sort(foldersPath.begin(), foldersPath.end());

std::sort(filesPath.begin(), filesPath.end());

}

auto Project::GetElideFileName(const std::filesystem::path& path, float maxSize) const -> std::string

{

std::string result = path.filename().u8string();

float currentSize = ImGui::CalcTextSize(result.c_str()).x;

while (currentSize > maxSize)

{

result.pop_back();

currentSize = ImGui::CalcTextSize(result.c_str()).x;

}

return result;

}

inline void Project::RenderParentFolder()

{

ImGui::BeginGroup();

ImGui::ImageButton("../", *folderIcon, ImVec2{ iconSize, iconSize }, ImVec2{ 0, 0 }, ImVec2{ 1, 1 }, iconBackgroundColor);

if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_::ImGuiMouseButton_Left))

{

currentPath = currentPath.parent_path();

GetAllFiles(currentPath);

}

float textWidth = ImGui::CalcTextSize("../").x;

float textOffset = (iconSize - textWidth) / 2.f;

if (textOffset >= 0.0f)

ImGui::SetCursorPosX(ImGui::GetCursorPosX() + textOffset);

ImGui::Text("../");

ImGui::EndGroup();

}

inline void Project::SetDragItem(const std::filesystem::path& path)

{

void* item = nullptr;

std::string pathStr = path.string();

std::string extension = path.extension().string();

std::string payloadName = "asset";

if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_::ImGuiDragDropFlags_None))

{

if (extension == ".obj")

{

payloadName = core::reflection::GetTypeName<render::Mesh*>();

item = world.meshes.GetResource(pathStr);

if (item == nullptr)

{

game::ModelLoader loader{ world.renderer };

item = world.meshes.AddResource(pathStr, loader.Load(pathStr));

}

}

else if (extension == ".mat")

{

payloadName = core::reflection::GetTypeName<render::Material*>();

item = world.materials.GetResource(pathStr);

if (item == nullptr)

AssetDatabase::ImportAsset(world, path);

}

else if (extension == ".png" || extension == ".jpg")

{

payloadName = core::reflection::GetTypeName<render::Texture*>();

item = world.textures.GetResource(pathStr);

if (item == nullptr)

AssetDatabase::ImportAsset(world, path);

}

ImGui::SetDragDropPayload(payloadName.c_str(), &item, sizeof(render::Mesh*));

ImGui::Text("%s", path.filename().c_str());

ImGui::EndDragDropSource();

}

}

inline auto Project::GetIcon(const std::filesystem::path& path) const -> const game::GUITexture*

{

std::string extension = path.extension().string();

const game::GUITexture* icon = folderIcon;

if (std::filesystem::is_regular_file(path))

{

icon = fileIcon;

if (extension == ".obj")

icon = meshIcon;

else if (extension == ".mat")

icon = EditorResource::GetInstance()->GetIcon(EditorResource::Icon::Material);

}

return icon;

}

inline bool Project::RenderFile(const std::filesystem::path& path, float& cursorX, float spacing, float width)

{

cursorX = ImGui::GetCursorPosX();

if (cursorX + iconSize > width)

{

ImGui::NewLine();

cursorX = ImGui::GetCursorPosX();

}

ImGui::BeginGroup();

const game::GUITexture* icon = GetIcon(path);

ImGui::PushStyleColor(ImGuiCol_::ImGuiCol_Button, iconBackgroundColor);

if (ImGui::ImageButton(path.string().c_str(), *icon, ImVec2{ iconSize, iconSize }))

{

auto uuidStr = AssetDatabase::GetAssetUUID(path);

if (uuidStr)

{

auto objPtr = core::SObjectManager::GetInstance()->GetSObject(uuidStr.value().ToString());

if (core::IsValid(objPtr))

world.SetSelectedObject(objPtr);

}

}

SetDragItem(path);

ImGui::PopStyleColor();

// 폴더면 더블 클릭 시 경로 변경

if (std::filesystem::is_directory(path))

{

if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_::ImGuiMouseButton_Left))

{

ImGui::EndGroup();

currentPath = path;

GetAllFiles(currentPath);

return false;

}

}

std::string name = GetElideFileName(path, iconSize);

float textWidth = ImGui::CalcTextSize(name.c_str()).x;

float textOffset = (iconSize - textWidth) / 2.f;

if (textOffset >= 0.0f)

ImGui::SetCursorPosX(ImGui::GetCursorPosX() + textOffset);

ImGui::Text("%s", name.c_str());

ImGui::EndGroup();

ImGui::SameLine(0.0f, spacing);

cursorX += iconSize + spacing;

return true;

}

inline void Project::ShowRightClickPopup()

{

if (ImGui::BeginPopupContextWindow("ProjectRightClickPopup"))

{

if (ImGui::BeginMenu("Create"))

{

if (ImGui::MenuItem("Folder"))

{

core::FileSystem::CreateFolder(currentPath, "NewFolder");

GetAllFiles(currentPath);

}

if (ImGui::MenuItem("Material"))

{

static render::Shader* defaultShader = world.shaders.GetResource("Default");

assert(defaultShader);

std::string name{ core::FileSystem::CreateUniqueFileName(currentPath, "NewMaterial.mat") };

auto mat = world.materials.AddResource(name, render::Material{ defaultShader });

mat->SetName(name);

mat->Build(world.renderer);

AssetDatabase::CreateAsset(world, currentPath / name, *mat);

GetAllFiles(currentPath);

}

ImGui::EndMenu();

}

ImGui::EndPopup();

}

}

SH_EDITOR_API void Project::Update()

{

}

SH_EDITOR_API void Project::Render()

{

static ImGuiWindowFlags style =

ImGuiWindowFlags_::ImGuiWindowFlags_AlwaysVerticalScrollbar | ImGuiWindowFlags_NoBringToFrontOnFocus;

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

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

float cursorX = ImGui::GetCursorPosX();

float spacing = ImGui::GetStyle().ItemSpacing.x;

if (currentPath != rootPath)

{

RenderParentFolder();

ImGui::SameLine();

}

for (auto& path : foldersPath)

{

if (!RenderFile(path, cursorX, spacing, availableWidth))

break;

}

for (auto& path : filesPath)

{

if (std::find(invisibleExtensions.begin(), invisibleExtensions.end(), path.extension().string()) != invisibleExtensions.end())

continue;

if (!RenderFile(path, cursorX, spacing, availableWidth))

break;

}

ShowRightClickPopup();

ImGui::End();

}

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

{

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

{

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

return;

}

rootPath = dir;

currentPath = dir;

GetAllFiles(currentPath);

}

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

{

rootPath = dir;

currentPath = dir;

GetAllFiles(currentPath);

AssetDatabase::LoadAllAssets(world, dir, true);

}

SH_EDITOR_API void Project::SaveWorld()

{

std::ofstream os{ rootPath / "test.world" };

os << std::setw(4) << world.Serialize();

os.close();

}

SH_EDITOR_API void Project::LoadWorld()

{

core::FileLoader loader{};

auto file = loader.LoadText((rootPath / "test.world").string());

if (file)

{

world.Deserialize(core::Json::parse(file.value()));

}

}

}