#include "BuildSystem.h"

#include "AssetDatabase.h"

#include "Meta.h"

#include "Project.h"

#include "EditorResource.h"

#include "Core/AssetBundle.h"

#include "Core/FileSystem.h"

#include "Game/World.h"

#include "Game/GameObject.h"

#include "Game/GameManager.h"

#include "Game/Asset/WorldAsset.h"

#include "Game/Asset/ShaderAsset.h"

#include "Game/Asset/MaterialAsset.h"

#include "Game/Asset/MeshAsset.h"

#include "Game/Asset/TextureAsset.h"

#include <fstream>

namespace sh::editor

{

BuildSystem::BuildSystem() :

uuidRegex("^[0-9a-f]{32}$", std::regex::optimize)

{

}

SH_EDITOR_API void BuildSystem::Build(Project& project, const std::filesystem::path& outputPath)

{

worldUUIDs.clear();

uuids.clear();

currentProject = &project;

core::AssetBundle bundle;

std::vector<game::World*> worldPtrs;

if (!project.GetProjectSetting().startingWorldUUID.IsEmpty())

{

auto objPtr = core::SObjectManager::GetInstance()->GetSObject(project.GetProjectSetting().startingWorldUUID);

worldPtrs.push_back(static_cast<game::World*>(objPtr));

}

for (int i = 0; i < worldPtrs.size(); ++i)

{

auto worldPtr = worldPtrs[i];

core::Json worldJson{};

if (worldPtr->IsLoaded())

worldJson = worldPtr->Serialize();

else

{

core::Json* worldPointPtr = worldPtr->GetWorldPoint();

if (worldPointPtr == nullptr)

{

SH_WARN_FORMAT("World({}) is empty!", worldPtr->GetUUID().ToString());

continue;

}

worldJson = *worldPointPtr;

}

std::unordered_set<std::string> uuids;

ExtractUUIDs(uuids, worldJson);

for (const auto& uuidStr : uuids)

{

const core::UUID uuid{ uuidStr };

this->uuids.insert(uuidStr);

worldUUIDs[worldPtr->GetUUID().ToString()].push_back(uuidStr);

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

if (obj != nullptr)

{

if (obj->GetType().IsChildOf(game::World::GetStaticType()))

{

auto it = std::find(worldPtrs.begin(), worldPtrs.end(), static_cast<game::World*>(obj));

if (it == worldPtrs.end())

worldPtrs.push_back(static_cast<game::World*>(obj));

}

}

}

PackingAssets(bundle, *worldPtr);

}

bundle.SaveBundle(outputPath / "assets.bundle");

ExportGameManager(outputPath / "gameManager.bin");

CopyRuntimeBinaries(outputPath);

}

void BuildSystem::CopyRuntimeBinaries(const std::filesystem::path& outputPath)

{

const std::filesystem::path engineDir = core::FileSystem::GetExecutableDirectory();

#if _WIN32

constexpr const char* exeExt = ".exe";

constexpr const char* libExt = ".dll";

constexpr const char* libPrefix = "";

#else

constexpr const char* exeExt = "";

constexpr const char* libExt = ".so";

constexpr const char* libPrefix = "lib";

#endif

const std::vector<std::string> executables = {

"ShellGame"

};

const std::vector<std::string> libraries = {

"ShellEngineCore",

"ShellEngineWindow",

"ShellEngineRender",

"ShellEnginePhysics",

"ShellEngineGame",

"ShellEngineNetwork",

"ShellEngineSound"

};

#if _WIN32

const std::vector<std::string> extraFiles = {

"OpenAL32.dll"

};

#else

const std::vector<std::string> extraFiles = {

"libopenal.so"

};

#endif

const std::vector<std::string> directories = {

"fonts"

};

std::error_code ec;

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

std::filesystem::create_directories(outputPath, ec);

auto copyIfMissingFn = [&](const std::filesystem::path& src, const std::filesystem::path& dst)

{

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

{

SH_WARN_FORMAT("Runtime binary not found in engine path: {}", src.u8string());

return;

}

std::error_code copyEc;

std::filesystem::copy_file(src, dst, std::filesystem::copy_options::overwrite_existing, copyEc);

if (copyEc)

SH_ERROR_FORMAT("Failed to copy {} -> {}: {}", src.u8string(), dst.u8string(), copyEc.message());

};

for (const std::string& name : executables)

{

const std::string fileName = name + exeExt;

copyIfMissingFn(engineDir / fileName, outputPath / fileName);

}

for (const std::string& name : libraries)

{

const std::string fileName = libPrefix + name + libExt;

copyIfMissingFn(engineDir / fileName, outputPath / fileName);

}

for (const std::string& fileName : extraFiles)

{

copyIfMissingFn(engineDir / fileName, outputPath / fileName);

}

for (const std::string& dirName : directories)

{

const std::filesystem::path src = engineDir / dirName;

const std::filesystem::path dst = outputPath / dirName;

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

{

SH_WARN_FORMAT("Runtime directory not found in engine path: {}", src.u8string());

continue;

}

std::error_code copyEc;

std::filesystem::copy(src, dst,

std::filesystem::copy_options::recursive |

std::filesystem::copy_options::overwrite_existing,

copyEc);

if (copyEc)

SH_ERROR_FORMAT("Failed to copy directory {} -> {}: {}", src.u8string(), dst.u8string(), copyEc.message());

}

}

void BuildSystem::ExtractUUIDs(std::unordered_set<std::string>& set, const core::Json& worldJson)

{

if (worldJson.is_object())

{

for (auto const& [key, val] : worldJson.items())

{

ExtractUUIDs(set, val);

}

}

else if (worldJson.is_array())

{

for (const auto& item : worldJson)

{

ExtractUUIDs(set, item);

}

}

else if (worldJson.is_string())

{

const std::string& value = worldJson.get<std::string>();

if (std::regex_match(value, uuidRegex))

{

if (set.find(value) == set.end())

{

set.insert(value);

core::SObject* obj = core::SObjectManager::GetInstance()->GetSObject(core::UUID{ value });

if (core::IsValid(obj))

{

ExtractUUIDs(set,obj->Serialize());

}

}

}

}

}

void BuildSystem::PackingAssets(core::AssetBundle& bundle, game::World& world)

{

auto editorResource = EditorResource::GetInstance();

game::ShaderAsset errorShaderAsset{ *editorResource->GetShader("ErrorShader") };

bundle.AddAsset(errorShaderAsset, true);

game::ShaderAsset lineShaderAsset{ *editorResource->GetShader("Line") };

bundle.AddAsset(lineShaderAsset, true);

game::ShaderAsset uiTextShaderAsset{ *editorResource->GetShader("UITextShader") };

bundle.AddAsset(uiTextShaderAsset, true);

game::ShaderAsset ssaoShaderAsset{ *editorResource->GetShader("SSAOShader") };

bundle.AddAsset(ssaoShaderAsset, true);

game::MaterialAsset errorMatAsset{ *editorResource->GetMaterial("ErrorMaterial") };

bundle.AddAsset(errorMatAsset, true);

game::MaterialAsset lineMatAsset{ *editorResource->GetMaterial("LineMaterial") };

bundle.AddAsset(lineMatAsset, true);

game::MaterialAsset uiTextMatAsset{ *editorResource->GetMaterial("UITextMaterial") };

bundle.AddAsset(uiTextMatAsset, true);

game::MeshAsset cubeMesh{ *editorResource->GetModel("CubeModel")->GetMeshes()[0] };

bundle.AddAsset(cubeMesh, true);

game::MeshAsset sphereMesh{ *editorResource->GetModel("SphereModel")->GetMeshes()[0] };

bundle.AddAsset(sphereMesh, true);

game::MeshAsset planeMesh{ *editorResource->GetModel("PlaneModel")->GetMeshes()[0] };

bundle.AddAsset(planeMesh, true);

game::TextureAsset blackTex{ *editorResource->GetTexture("BlackTexture") };

bundle.AddAsset(blackTex, true);

for (const auto& uuid : uuids)

{

auto obj = core::SObjectManager::GetInstance()->GetSObject(core::UUID{ uuid });

if (obj != nullptr)

{

if (obj->GetType().IsChildOf(game::World::GetStaticType()))

continue;

}

auto asset = AssetDatabase::GetInstance()->GetAsset(core::UUID{ uuid });

if (asset != nullptr)

bundle.AddAsset(*asset, true);

}

game::WorldAsset worldAsset{ world };

worldAsset.ConvertToGameWorldType();

bundle.AddAsset(worldAsset, true);

}

void BuildSystem::ExportGameManager(const std::filesystem::path& outputPath)

{

game::GameManager& manager = *game::GameManager::GetInstance();

ProjectSetting& projectSetting = currentProject->GetProjectSetting();

core::Json mainJson;

if (!projectSetting.startingWorldUUID.IsEmpty())

mainJson["starting"] = projectSetting.startingWorldUUID.ToString();

for (const auto& [worldUUIDStr, uuids] : worldUUIDs)

{

core::Json worldUUIDs{};

for (const auto& uuid : uuids)

{

worldUUIDs[worldUUIDStr].push_back(uuid);

}

mainJson["uuids"].push_back(std::move(worldUUIDs));

}

const std::vector<uint8_t> data{ core::Json::to_bson(mainJson) };

std::ofstream of{ outputPath, std::ios_base::binary };

if (!of.is_open())

{

SH_ERROR_FORMAT("Failed to export game setting!: {}", outputPath.u8string());

return;

}

of.write(reinterpret_cast<const char*>(data.data()), data.size());

of.close();

}

}//namespace