5#include "../Manager/SCloneFactory.h" 
    6#include "../Manager/ResMgr.h" 
    8#include "SGameObject.h" 
    9#include "../Util/Loader/DAE/DAELoader.h" 
   10#include "../Util/AssetsDef.h" 
   11#include "SGameObjectFromSPrefab.h" 
   17SPrefab::~SPrefab() = 
default;
 
   19void SPrefab::Exterminate() {
 
   23    SGameObject* clone = SCloneFactory::Clone(m_root, parent);
 
   25    clone->GetTransform()->m_position = 
vec3(position);
 
   26    clone->SetIsPrefab(
false);
 
   27    clone->SetUndestroyable(
false);
 
   34    SGameObject* clone = SCloneFactory::Clone(m_root, parent);
 
   36    clone->GetTransform()->m_position = 
vec3(position);
 
   37    clone->GetTransform()->m_scale = 
vec3(scale);
 
   38    clone->GetTransform()->m_rotation = 
Quaternion(rotation);
 
   39    clone->SetIsPrefab(
false);
 
   40    clone->SetUndestroyable(
false);
 
   46    if (m_root != 
nullptr) 
return false;
 
   49    m_root->SetUndestroyable(
true);
 
   50    m_root->SetIsPrefab(
true);
 
   51    m_root->SetResourceID(GetHash(), 
true);
 
   57    AssetMgr::TYPE type = asset->type;
 
   58    std::string path = asset->name_path;
 
   62            DAELoader::GeneratePrefab(path.c_str(), 
nullptr, 
nullptr, 
nullptr, 
this);
 
   66    std::string hashRaw = AssetMgr::LoadAssetFile(path + 
".meta");
 
   67    if(!hashRaw.empty()) {
 
   68        const XNode* root = 
XFILE().loadBuffer(hashRaw);
 
   69        const auto& hashData = root->getNode(
"hash-data");
 
   70        std::string hash = hashData.getAttribute(
"hash").value;
 
   72        const auto& hashChildren = hashData.children;
 
   74        if(hashData.children.size() <= 0) {
 
   75            hashRaw = 
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 
   76                      "<CSEMETA version=\"1.0.0\">\n" 
   77                      "<hash-data hash=\"" + m_hash + 
"\">\n" 
   78                      + GenerateObjectMeta(*m_root) +
 
   79                      "\n</hash-data>\n</CSEMETA>";
 
   80            SaveTxtFile(path + 
".meta", hashRaw);
 
   83            for(
const auto& child : hashChildren) {
 
   84                const auto& 
id = child.getAttribute(
"id").value;
 
   85                std::string hash = child.value;
 
   87                if(obj == 
nullptr) 
continue;
 
   89                obj->SetRefHash(hash);
 
  100        obj->SetResourceID(GetHash());
 
  102        std::string resultID = obj->GetID();
 
  103        resultID = resultID.substr(resultID.find(
'/') + 1);
 
  104        obj->SetResourceID(std::string(GetHash()) + 
"*" + resultID);
 
  107    for (
auto child : obj->GetChildren()) {
 
  108        GenerateResourceID(child);
 
  112std::string SPrefab::GetMetaString(
const SGameObject& 
object, 
unsigned int startIndex) {
 
  113    std::string&& 
id = 
object.GetID().substr(startIndex);
 
  114    std::string&& hash = 
object.GetHash();
 
  116    std::string result = 
"<hash id=\"" + std::move(
id) + 
"\">" + std::move(hash) + 
"</hash>";
 
  118    const auto& children = 
object.GetChildren();
 
  119    for (
const auto& child: children) {
 
  120        result += 
'\n' + GetMetaString(*child, startIndex);
 
  125std::string SPrefab::GenerateObjectMeta(
const SGameObject& obj) {
 
  126    unsigned int startIndex = obj.GetID().size() - obj.GetName().size();
 
  127    return GetMetaString(obj, startIndex);
 
  134std::string SPrefab::PrintValue()
 const {
 
void SetValue(std::string name_str, Arguments value) override