#include "AssetDatabase.h"

#include "AssetExtensions.h"

#include "Meta.h"

#include "EditorWorld.h"

#include "Core/FileSystem.h"

#include "Core/Asset.h"

#include "Core/AssetImporter.h"

#include "Core/AssetExporter.h"

#include "Core/Logger.h"

#include "Render/Renderer.h"

#include "Render/Model.h"

#include "Render/SkinnedMesh.h"

#include "Render/VulkanImpl/VulkanShaderPassBuilder.h"

#include "Render/VulkanImpl/VulkanContext.h"

#include "Game/World.h"

#include "Game/Prefab.h"

#include "Game/Asset/TextureLoader.h"

#include "Game/Asset/ModelLoader.h"

#include "Game/Asset/MeshLoader.h"

#include "Game/Asset/MaterialLoader.h"

#include "Game/Asset/ShaderLoader.h"

#include "Game/Asset/WorldLoader.h"

#include "Game/Asset/PrefabLoader.h"

#include "Game/Asset/BinaryLoader.h"

#include "Game/Asset/SoundLoader.h"

#include "Game/Asset/TextLoader.h"

#include "Game/Asset/FontLoader.h"

#include "Game/Asset/ScriptableObjectLoader.h"

#include "Game/Asset/ComputeShaderLoader.h"

#include "Game/Asset/TextureAsset.h"

#include "Game/Asset/ModelAsset.h"

#include "Game/Asset/MeshAsset.h"

#include "Game/Asset/MaterialAsset.h"

#include "Game/Asset/ShaderAsset.h"

#include "Game/Asset/WorldAsset.h"

#include "Game/Asset/PrefabAsset.h"

#include "Game/Asset/BinaryAsset.h"

#include "Game/Asset/SoundAsset.h"

#include "Game/Asset/TextAsset.h"

#include "Game/Asset/FontAsset.h"

#include "Game/Asset/ScriptableObjectAsset.h"

#include "Game/Asset/ComputeShaderAsset.h"

#include "Sound/SoundClip.h"

#include <istream>

#include <ostream>

#include <cassert>

#include <algorithm>

#include <fstream>

#include <cstdint>

#include <chrono>

namespace sh::editor

{

AssetDatabase::AssetDatabase()

{

projectPath = std::filesystem::current_path();

onDestroyListener.SetCallback(

[&](const core::SObject* destoryedObj)

{

auto it = std::find(dirtyObjs.begin(), dirtyObjs.end(), destoryedObj);

if (it != dirtyObjs.end())

dirtyObjs.erase(it);

}

);

}

SH_EDITOR_API void AssetDatabase::Init(const std::filesystem::path& projectPath, const render::IRenderContext& ctx, const game::ImGUImpl& imgui)

{

this->projectPath = projectPath;

this->guiCtx = &imgui;

libPath = projectPath / "Library";

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

std::filesystem::create_directories(libPath);

assert(ctx.GetRenderAPIType() == render::RenderAPI::Vulkan); // TODO

static render::vk::VulkanShaderPassBuilder passBuilder{ static_cast<const render::vk::VulkanContext&>(ctx) };

std::unique_ptr<game::ShaderLoader> shaderLoader = std::make_unique<game::ShaderLoader>(&passBuilder);

shaderLoader->SetCachePath(projectPath / "temp");

std::unique_ptr<game::ComputeShaderLoader> computeShaderLoader = std::make_unique<game::ComputeShaderLoader>(ctx);

computeShaderLoader->SetCachePath(projectPath / "temp");

assetLoaders.Clear();

assetLoaders.RegisterLoader(AssetExtensions::Type::Model, std::make_unique<game::ModelLoader>(ctx), 2, true);

assetLoaders.RegisterLoader(AssetExtensions::Type::Mesh, std::make_unique<game::MeshLoader>(ctx), 2, true);

assetLoaders.RegisterLoader(AssetExtensions::Type::Texture, std::make_unique<game::TextureLoader>(ctx), 2, true);

assetLoaders.RegisterLoader(AssetExtensions::Type::ComputeShader, std::move(computeShaderLoader), 2, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Shader, std::move(shaderLoader), 2, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Binary, std::make_unique<game::BinaryLoader>(), 2, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Sound, std::make_unique<game::SoundLoader>(), 2, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Text, std::make_unique<game::TextLoader>(), 2, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Material, std::make_unique<game::MaterialLoader>(ctx), 1, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Font, std::make_unique<game::FontLoader>(), 1, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::Prefab, std::make_unique<game::PrefabLoader>(), 1, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::World, std::make_unique<game::WorldLoader>(), 0, false);

assetLoaders.RegisterLoader(AssetExtensions::Type::ScriptableObject, std::make_unique<game::ScriptableObjectLoader>(), -1, false);

}

SH_EDITOR_API void AssetDatabase::SaveDatabase(const std::filesystem::path& dir)

{

core::Json json{};

for (auto it = paths.begin(); it != paths.end(); ++it)

{

const core::UUID& uuid = it->first;

const auto& originalPath = it->second.originalPath;

const auto& cachePath = it->second.cachePath;

core::Json uuidJson{};

uuidJson["0"] = originalPath.u8string();

uuidJson["1"] = cachePath.u8string();

json[uuid.ToString()] = uuidJson;

}

std::ofstream os{ dir };

os << std::setw(4) << json;

os.close();

}

SH_EDITOR_API auto AssetDatabase::LoadDatabase(const std::filesystem::path& dir) -> bool

{

auto opt = core::FileSystem::LoadText(dir);

if (!opt.has_value())

return false;

paths.clear();

core::Json json = core::Json::parse(opt.value());

if (json.empty())

{

SH_ERROR_FORMAT("Parsing failed: {}", dir.u8string());

}

if (json.is_array())

json = json[0];

for (auto it = json.begin(); it != json.end(); ++it)

{

core::UUID uuid{ it.key() };

const auto& uuidJson = it.value();

if (!uuidJson.contains("0") || !uuidJson.contains("1"))

continue;

AssetInfo info{};

info.originalPath = std::filesystem::u8path(uuidJson["0"].get<std::string>());

info.cachePath = std::filesystem::u8path(uuidJson["1"].get<std::string>());

paths.insert_or_assign(uuid, std::move(info));

uuids.insert_or_assign(info.originalPath, uuid);

}

return true;

}

SH_EDITOR_API void AssetDatabase::SaveAllAssets()

{

for (auto obj : dirtyObjs)

{

if (!core::IsValid(obj))

continue;

auto it = paths.find(obj->GetUUID());

if (it == paths.end())

continue;

const auto& [originalPath, cachePath] = it->second;

if (!std::filesystem::exists(projectPath / originalPath))

{

SH_ERROR_FORMAT("{} is not exists!", originalPath.u8string());

continue;

}

const uint64_t writeTime = std::filesystem::last_write_time(projectPath / originalPath).time_since_epoch().count();

const std::string ext = originalPath.extension().u8string();

const AssetExtensions::Type type = AssetExtensions::CheckType(ext);

const AssetLoaderRegistry::Importer* const importer = assetLoaders.GetLoader(type);

if (importer->bObjDataInMeta)

{

Meta meta{};

meta.SaveWithObj(*obj, Meta::CreateMetaDirectory(projectPath / originalPath), false);

}

else

{

std::ofstream os{ projectPath / originalPath };

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

os.close();

Meta meta{};

meta.Save(*obj, Meta::CreateMetaDirectory(projectPath / originalPath), false);

}

ExportAsset(*obj, projectPath / cachePath, writeTime);

}

dirtyObjs.clear();

}

SH_EDITOR_API void AssetDatabase::LoadAllAssets(const std::filesystem::path& dir, bool recursive, bool bOverLoad)

{

LoadAllAssetsHelper(dir, recursive);

while (!loadingAssetsQueue.empty())

{

AssetLoadData data = std::move(const_cast<AssetLoadData&>(loadingAssetsQueue.top()));

loadingAssetsQueue.pop();

ImportAsset(data.path, bOverLoad);

}

SaveDatabase(libPath / "AssetDB.json");

}

SH_EDITOR_API auto AssetDatabase::ImportAsset(const std::filesystem::path& dir, bool bOverLoad) -> core::SObject*

{

std::filesystem::path abPath = dir;

if (dir.is_relative())

abPath = projectPath / abPath;

if (!bOverLoad)

{

auto uuidOpt = GetAssetUUID(abPath);

if (uuidOpt.has_value())

{

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

if (sobjPtr != nullptr)

return sobjPtr;

}

}

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

return nullptr;

if (std::filesystem::is_directory(abPath))

return nullptr;

const std::string extension = abPath.extension().string();

if (extension != ".asset")

{

const AssetExtensions::Type type = AssetExtensions::CheckType(extension);

const AssetLoaderRegistry::Importer* const importerPtr = assetLoaders.GetLoader(type);

if (importerPtr == nullptr)

return nullptr;

const bool bAssetChanged = IsAssetChanged(abPath);

core::SObject* const objPtr = LoadAsset(abPath, *importerPtr->loader, importerPtr->bObjDataInMeta);

// 모델 파일은 특수처리 필요

if (type == AssetExtensions::Type::Model)

{

if (objPtr != nullptr && bAssetChanged)

{

render::Model* const modelPtr = static_cast<render::Model*>(objPtr);

for (const auto& mesh : modelPtr->GetMeshes())

{

if (mesh == nullptr)

continue;

const std::filesystem::path cachePath{ libPath / fmt::format("{}.asset", mesh->GetUUID().ToString()) };

ExportAsset(*mesh, cachePath);

paths.insert_or_assign(mesh->GetUUID(), AssetInfo{ std::filesystem::relative(cachePath, projectPath), std::filesystem::relative(cachePath, projectPath) });

}

}

}

if (objPtr != nullptr)

onAssetImported.Notify(objPtr);

return objPtr;

}

// .asset파일의 경우 그냥 불러오고 포인터 반환

std::unique_ptr<core::Asset> asset = core::AssetImporter::Load(projectPath / abPath);

if (asset == nullptr)

return nullptr;

const AssetLoaderRegistry::Importer* const importerPtr = assetLoaders.GetLoader(asset->GetType());

if (importerPtr == nullptr)

return nullptr;

return importerPtr->loader->Load(*asset);

}

SH_EDITOR_API bool AssetDatabase::CreateAsset(const std::filesystem::path& dir, const core::SObject& obj)

{

if (std::filesystem::exists(dir))

return false;

const std::filesystem::path relativePath = std::filesystem::relative(dir, projectPath);

const std::filesystem::path cachePath = libPath / fmt::format("{}.asset", obj.GetUUID().ToString());

if (!ExportAsset(obj, cachePath))

return false;

if (relativePath.empty())

return false;

uuids.insert_or_assign(relativePath, obj.GetUUID());

paths.insert_or_assign(obj.GetUUID(), AssetInfo{relativePath, std::filesystem::relative(cachePath, projectPath)});

std::ofstream os(dir);

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

os.close();

Meta meta{};

meta.Save(obj, Meta::CreateMetaDirectory(dir));

onAssetImported.Notify(const_cast<core::SObject*>(&obj));

return true;

}

SH_EDITOR_API void AssetDatabase::AssetWasMoved(const core::UUID& uuid, const std::filesystem::path& newPath)

{

auto it = paths.find(uuid);

if (it == paths.end())

return;

std::filesystem::path relativePath = std::filesystem::relative(newPath, projectPath);

uuids.erase(std::filesystem::relative(it->second.originalPath));

uuids.insert_or_assign(relativePath, uuid);

it->second.originalPath = relativePath;

SaveDatabase(libPath / "AssetDB.json");

}

SH_EDITOR_API void AssetDatabase::DeleteAsset(const core::UUID& uuid)

{

auto it = paths.find(uuid);

if (it == paths.end())

return;

const auto& filePath = projectPath / it->second.originalPath;

const auto& cachePath = projectPath / it->second.originalPath;

if(std::filesystem::exists(filePath))

std::filesystem::remove(filePath);

if (std::filesystem::exists(cachePath))

std::filesystem::remove(cachePath);

const auto metaPath = Meta::CreateMetaDirectory(projectPath / it->second.originalPath);

if (std::filesystem::exists(metaPath))

std::filesystem::remove(metaPath);

uuids.erase(it->second.originalPath);

paths.erase(it);

auto objPtr = core::SObjectManager::GetInstance()->GetSObject(uuid);

if (objPtr != nullptr)

{

objPtr->Destroy();

onAssetRemoved.Notify(uuid);

}

SaveDatabase(libPath / "AssetDB.json");

}

SH_EDITOR_API void AssetDatabase::MoveAssetToDirectory(const core::UUID& uuid, const std::filesystem::path& directoryPath)

{

auto it = paths.find(uuid);

if (it == paths.end())

return;

std::filesystem::path newPath;

if (directoryPath.is_relative())

{

if (!std::filesystem::exists(projectPath / directoryPath) || !std::filesystem::is_directory(projectPath / directoryPath))

return;

newPath = projectPath / "Assets" / directoryPath / it->second.originalPath.filename();

}

else

{

if (!std::filesystem::exists(directoryPath) || !std::filesystem::is_directory(directoryPath))

return;

newPath = directoryPath / it->second.originalPath.filename();

}

const auto& filePath = projectPath / it->second.originalPath;

std::filesystem::rename(filePath, newPath);

const auto metaPath = Meta::CreateMetaDirectory(filePath);

if (std::filesystem::exists(metaPath))

std::filesystem::rename(metaPath, Meta::CreateMetaDirectory(newPath));

AssetWasMoved(uuid, newPath);

}

SH_EDITOR_API auto AssetDatabase::GetAsset(const core::UUID& uuid) -> std::unique_ptr<core::Asset>

{

auto it = paths.find(uuid);

if (it == paths.end())

return nullptr;

return core::AssetImporter::Load(projectPath / it->second.cachePath);

}

SH_EDITOR_API auto AssetDatabase::GetAssetPath(const core::UUID& uuid) const -> const AssetInfo*

{

auto it = paths.find(uuid);

if (it == paths.end())

return nullptr;

return &it->second;

}

SH_EDITOR_API auto AssetDatabase::GetAssetUUID(const std::filesystem::path& assetPath) -> std::optional<core::UUID>

{

std::filesystem::path relativePath{};

if (assetPath.is_absolute())

relativePath = std::filesystem::relative(assetPath, projectPath);

else

relativePath = assetPath;

auto it = uuids.find(relativePath);

if (it == uuids.end())

return {};

return it->second;

}

SH_EDITOR_API void AssetDatabase::SetDirty(core::SObject* obj)

{

obj->onDestroy.Register(onDestroyListener);

if(core::IsValid(obj))

dirtyObjs.push_back(obj);

}

SH_EDITOR_API auto AssetDatabase::ExportAsset(const core::SObject& obj, const std::filesystem::path& path, int64_t writeTime) const -> bool

{

std::string assetType;

if (obj.GetType() == render::Texture::GetStaticType())

assetType = game::TextureAsset::ASSET_NAME;

else if (obj.GetType() == render::Model::GetStaticType())

assetType = game::ModelAsset::ASSET_NAME;

else if (obj.GetType() == game::World::GetStaticType() || obj.GetType() == editor::EditorWorld::GetStaticType())

assetType = game::WorldAsset::ASSET_NAME;

else if (obj.GetType() == render::Material::GetStaticType())

assetType = game::MaterialAsset::ASSET_NAME;

else if (obj.GetType() == render::Mesh::GetStaticType())

assetType = game::MeshAsset::ASSET_NAME;

else if (obj.GetType() == render::SkinnedMesh::GetStaticType())

assetType = game::MeshAsset::ASSET_NAME;

else if (obj.GetType() == render::Shader::GetStaticType())

assetType = game::ShaderAsset::ASSET_NAME;

else if (obj.GetType() == game::Prefab::GetStaticType())

assetType = game::PrefabAsset::ASSET_NAME;

else if (obj.GetType() == game::BinaryObject::GetStaticType())

assetType = game::BinaryAsset::ASSET_NAME;

else if (obj.GetType() == game::TextObject::GetStaticType())

assetType = game::TextAsset::ASSET_NAME;

else if (obj.GetType() == render::Font::GetStaticType())

assetType = game::FontAsset::ASSET_NAME;

else if (obj.GetType() == sound::SoundClip::GetStaticType())

assetType = game::SoundAsset::ASSET_NAME;

else if (obj.GetType().IsChildOf(game::ScriptableObject::GetStaticType()))

assetType = game::ScriptableObjectAsset::ASSET_NAME;

else if (obj.GetType() == render::ComputeShader::GetStaticType())

assetType = game::ComputeShaderAsset::ASSET_NAME;

else

{

SH_ERROR_FORMAT("Failed to export asset (type: {})", obj.GetType().name.ToString());

return false;

}

std::unique_ptr<core::Asset> asset = core::Factory<core::Asset>::GetInstance()->Create(assetType);

if (asset == nullptr)

{

SH_ERROR_FORMAT("Asset type({}) is invalid", assetType);

return false;

}

asset->SetAsset(obj);

if (writeTime > 0)

{

asset->SetWriteTime(writeTime);

if (!core::AssetExporter::Save(*asset, path, true))

{

SH_ERROR_FORMAT("Asset export failed: {}", path.u8string());

return false;

}

}

else

{

auto writeTime = std::filesystem::file_time_type::clock::now();

asset->SetWriteTime(writeTime.time_since_epoch().count());

if (!core::AssetExporter::Save(*asset, path, true))

{

SH_ERROR_FORMAT("Asset export failed: {}", path.u8string());

return false;

}

std::filesystem::last_write_time(path, writeTime);

}

return true;

}

SH_EDITOR_API auto AssetDatabase::IsAssetChanged(const std::filesystem::path& assetPath) -> bool

{

const std::filesystem::path metaPath{ Meta::CreateMetaDirectory(assetPath) };

// 처음 보는 경로의 에셋인 경우에도 변경으로 간주한다.

if (uuids.find(std::filesystem::relative(assetPath, projectPath)) == uuids.end())

return true;

Meta meta{};

// 메타 파일이 없는 경우에도 변경으로 친다.

if (!meta.Load(metaPath))

return true;

auto it = paths.find(meta.GetUUID());

if (it == paths.end())

return false;

const auto& [filePath, assetCachePath] = it->second;

std::unique_ptr<core::Asset> asset = core::AssetImporter::Load(projectPath / assetCachePath);

if (asset == nullptr)

return false;

const int64_t writeTime = std::filesystem::last_write_time(assetPath).time_since_epoch().count();

const int64_t assetWriteTime = asset->GetWriteTime();

const bool bMetaChanged = meta.IsChanged();

return (assetWriteTime != writeTime) || bMetaChanged;

}

SH_EDITOR_API auto AssetDatabase::GetAssetImporter(AssetExtensions::Type type) const -> const AssetLoaderRegistry::Importer*

{

return assetLoaders.GetLoader(type);

}

auto AssetDatabase::HasMetaFile(const std::filesystem::path& dir) -> std::optional<std::filesystem::path>

{

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

return std::nullopt;

std::filesystem::path metaFileDir = Meta::CreateMetaDirectory(dir);

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

return std::nullopt;

return metaFileDir;

}

void AssetDatabase::LoadAllAssetsHelper(const std::filesystem::path& dir, bool recursive)

{

for (auto& entry : std::filesystem::directory_iterator(dir))

{

if (entry.is_directory())

{

if (recursive)

LoadAllAssetsHelper(entry.path(), recursive);

}

else if (entry.is_regular_file())

{

const std::string extension = entry.path().extension().u8string();

if (extension == ".meta")

continue;

int priority = 0;

const auto type = AssetExtensions::CheckType(extension);

const auto importer = assetLoaders.GetLoader(type);

if (importer != nullptr)

priority = importer->priority;

loadingAssetsQueue.push(AssetLoadData{ priority, entry.path() });

}

}

}

auto AssetDatabase::LoadAsset(const std::filesystem::path& path, core::IAssetLoader& loader, bool bMetaSaveWithObj) -> core::SObject*

{

std::filesystem::path metaDir{ Meta::CreateMetaDirectory(path) };

std::filesystem::path relativePath{ std::filesystem::relative(path, projectPath) };

const int64_t writeTime = std::filesystem::last_write_time(path).time_since_epoch().count();

Meta meta{};

if (meta.Load(metaDir))

{

auto it = paths.find(meta.GetUUID());

if (it != paths.end())

{

const auto& [filePath, assetPath] = it->second;

std::unique_ptr<core::Asset> asset = core::AssetImporter::Load(projectPath / assetPath);

if (asset != nullptr)

{

int64_t assetWriteTime = asset->GetWriteTime();

bool bMetaChanged = meta.IsChanged();

if (assetWriteTime == writeTime && !bMetaChanged) // 다른 경우 에셋이 변경됐다는 뜻

{

core::SObject* objPtr = loader.Load(*asset.get());

if (objPtr == nullptr)

return nullptr;

objPtr->SetName(path.stem().u8string());

uuids.insert_or_assign(relativePath, objPtr->GetUUID());

return objPtr;

}

else

{

SH_INFO_FORMAT("Asset {} was changed!", relativePath.u8string());

}

}

}

}

core::SObject* objPtr = loader.Load(path);

if (objPtr == nullptr)

return nullptr;

if (meta.IsLoad())

meta.DeserializeSObject(*objPtr);

else

{

objPtr->SetName(path.stem().u8string());

}

std::filesystem::path cachePath{ libPath / fmt::format("{}.asset", objPtr->GetUUID().ToString()) };

if (!ExportAsset(*objPtr, cachePath, writeTime))

return nullptr;

uuids.insert_or_assign(relativePath, objPtr->GetUUID());

paths.insert_or_assign(objPtr->GetUUID(), AssetInfo{ relativePath, std::filesystem::relative(cachePath, projectPath) });

if (bMetaSaveWithObj)

meta.SaveWithObj(*objPtr, metaDir);

else

meta.Save(*objPtr, metaDir);

return objPtr;

}

}//namespace