Connor/cursebreaker-parser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

imgration 14/12/2025

Browse Source
This commit is contained in:
Connor De Meyer
2025-12-24 16:51:01 +09:00
parent 121eb8eb25
commit d8a8d9633d
46 changed files with 1866 additions and 1026 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
include/asset_base.hpp Normal file
View File

@@ -0,0 +1,120 @@
#pragma once
#include <filesystem>
#include <array>
#include <unordered_map>
#include <vector>
#include <string>
#include <string_view>
#include <ryml.hpp>
#include "type_info.hpp"
struct AssetGUID
{
AssetGUID() = default;
AssetGUID(const char* data) : AssetGUID(std::string_view(data, 32)) {};
AssetGUID(std::string_view data)
{
for (size_t i = 0; i < 16; ++i) Data[0] = (Data[0] << 4) | hexToVal(data[i]);
for (size_t i = 16; i < 32; ++i) Data[1] = (Data[1] << 4) | hexToVal(data[i]);
}
static uint64_t hexToVal(char c)
{
return (c >= '0' && c <= '9') ? (c - '0') : (c - 'a' + 10);
}
bool operator==(const AssetGUID& other) const
{
return Data[0] == other.Data[0] && Data[1] == other.Data[1];
}
static constexpr uint64_t DefaultVal = 0xe000000000000000;
std::array<uint64_t, 2> Data{ 0, DefaultVal };
};
struct AssetPath
{
std::filesystem::path path{};
AssetGUID GUID{};
};
template <typename T>
using unordered_map_guid = std::unordered_map<AssetGUID, T>;
namespace std
{
template <>
struct hash<AssetGUID> {
size_t operator()(const AssetGUID& v) const noexcept
{
auto h1 = std::hash<uint64_t>{}(v.Data[0]);
auto h2 = std::hash<uint64_t>{}(v.Data[1]);
return h1 ^ (h2 << 1);
}
};
}
inline AssetGUID ParseAssetGUID(const ryml::ConstNodeRef& node)
{
auto guidStringSpan2 = node["guid"].val();
assert(guidStringSpan2.size() == 32);
return AssetGUID{std::string_view(guidStringSpan2.data(), guidStringSpan2.size())};
}
struct AssetBase
{
std::filesystem::path Path{};
AssetGUID GUID{};
// static std::span<std::string_view> GetExtensions();
};
struct AssetCollectionBase
{
std::vector<std::unordered_map<AssetGUID, AssetBase*>*> AssetsInterface{};
std::vector<std::string_view> AssetNames{};
template <typename AssetType>
AssetType* GetAsset(AssetGUID guid)
{
for (size_t i = 0; i < AssetNames.size(); i++)
if (AssetNames[i] == type_name<AssetType>())
{
auto& assetMap = (*AssetsInterface[i]);
auto it = assetMap.find(guid);
if (it != assetMap.end())
{
return static_cast<AssetType*>(it->second);
}
return nullptr;
}
return nullptr;
}
};
template <typename AssetTypes = TypeCollection<>>
struct AssetCollection : public AssetCollectionBase
{
using AssetsT = typename AssetTypes::template AsContainedType<unordered_map_guid>;
AssetsT Assets;
AssetCollection(AssetsT&& assets)
: AssetNames(AssetTypes::get_names())
, AssetsInterface(sizeof...(AssetTypes))
, Assets(std::move(assets))
{
size_t index = 0;
AssetTypes::ForEachT([this, &index]<typename AssetT>()
{
AssetsInterface[index++] = &std::get<std::unordered_map<AssetGUID, AssetT>>(Assets);
});
}
};

86
include/assets/asset_base.hpp
View File

@@ -1,86 +0,0 @@
#pragma once
#include <cstdint>
#include <unordered_map>
#include <array>
#include <string_view>
#include <span>
#include <ryml.hpp>
#include <ryml_std.hpp>
#include <c4/format.hpp>
struct AssetBase
{
public:
int64_t ID;
};
struct AssetGUID
{
AssetGUID() = default;
AssetGUID(const char* data) : AssetGUID(std::string_view(data, 32)) {};
AssetGUID(std::string_view data)
{
for (size_t i = 0; i < 16; ++i) Data[0] = (Data[0] << 4) | hexToVal(data[i]);
for (size_t i = 16; i < 32; ++i) Data[1] = (Data[1] << 4) | hexToVal(data[i]);
}
static uint64_t hexToVal(char c)
{
return (c >= '0' && c <= '9') ? (c - '0') : (c - 'a' + 10);
}
bool operator==(const AssetGUID& other) const
{
return Data[0] == other.Data[0] && Data[1] == other.Data[1];
}
static constexpr uint64_t DefaultVal = 0xe000000000000000;
std::array<uint64_t, 2> Data{ 0, DefaultVal };
};
namespace std
{
template <>
struct hash<AssetGUID> {
size_t operator()(const AssetGUID& v) const noexcept
{
auto h1 = std::hash<uint64_t>{}(v.Data[0]);
auto h2 = std::hash<uint64_t>{}(v.Data[1]);
return h1 ^ (h2 << 1);
}
};
}
template <typename T>
T* ParseAssetRef(const ryml::ConstNodeRef& node)
{
T* asset;
node["fileID"] >> asset;
return asset;
}
template <typename T>
bool LinkAssetRef(const std::unordered_map<int64_t, AssetBase*>& assetsMap, T*& asset)
{
auto it = assetsMap.find(reinterpret_cast<int64_t>(asset));
if (it != assetsMap.end())
{
asset = reinterpret_cast<T*>(it->second);
return true;
}
asset = nullptr;
return false;
}
inline AssetGUID ParseAssetGUID(const ryml::ConstNodeRef& node)
{
auto guidStringSpan2 = node["guid"].val();
assert(guidStringSpan2.size() == 32);
return AssetGUID{std::string_view(guidStringSpan2.data(), guidStringSpan2.size())};
}

21
include/assets/custom_assets.hpp
View File

@@ -1,21 +0,0 @@
#pragma once
#include "asset_base.hpp"
struct Drop
{
int itemId;
int minAmount;
int maxAmount;
int dropChance;
};
struct Interactable_Resource : public AssetBase
{
int maxHealth;
int respawnTime;
std::vector<Drop> drops;
std::vector<int> requiredTools;
int xp;
int typeId;
};

54
include/assets/game_object.hpp
View File

@@ -1,54 +0,0 @@
#pragma once
#include <string>
#include <vector>
#include <ryml_std.hpp>
#include "asset_base.hpp"
#include "transform.hpp"
struct GameObjectAsset : public AssetBase
{
std::string name;
uint8_t layer{ 0 };
uint8_t namMeshLayer{ 0 };
std::string tag;
TransformAsset* transform{ nullptr };
std::vector<AssetBase*> Components;
};
inline GameObjectAsset ParseGameObject(const ryml::ConstNodeRef& node)
{
GameObjectAsset gameObject;
node["m_Name"] >> gameObject.name;
node["m_Layer"] >> gameObject.layer;
node["m_TagString"] >> gameObject.tag;
auto components = node["m_Component"];
auto it = components.begin();
gameObject.transform = ParseAssetRef<TransformAsset>((*it)["component"]);
++it;
for (; it != components.end(); ++it)
{
gameObject.Components.push_back(ParseAssetRef<AssetBase>((*it)["component"]));
}
return gameObject;
}
inline void LinkGameObject(const std::unordered_map<int64_t, AssetBase*>& assetsMap, GameObjectAsset& gameObject)
{
LinkAssetRef<TransformAsset>(assetsMap, gameObject.transform);
for (int i = static_cast<int>(gameObject.Components.size()) - 1; i >= 0; i--)
{
if (!LinkAssetRef<AssetBase>(assetsMap, gameObject.Components[i]))
{
std::swap(gameObject.Components[i], gameObject.Components.back());
gameObject.Components.pop_back();
}
}
}

0
include/assets/image.h Normal file
View File

0
include/assets/mesh.h Normal file
View File

29
include/assets/mesh_filter.hpp
View File

@@ -1,29 +0,0 @@
#pragma once
#include <string>
#include "asset_base.hpp"
struct GameObjectAsset;
struct MeshFilterAsset : AssetBase
{
AssetGUID Mesh;
GameObjectAsset* GameObject{ nullptr };
};
inline MeshFilterAsset ParseMeshFilter(const ryml::ConstNodeRef& node)
{
MeshFilterAsset meshFilter;
meshFilter.Mesh = ParseAssetGUID(node["m_Mesh"]);
meshFilter.GameObject = ParseAssetRef<GameObjectAsset>(node["m_GameObject"]);
return meshFilter;
}
inline void LinkMeshFilter(const std::unordered_map<int64_t, AssetBase*>& assetsMap, MeshFilterAsset& meshFilter)
{
LinkAssetRef<GameObjectAsset>(assetsMap, meshFilter.GameObject);
}

29
include/assets/prefab.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include "asset_base.hpp"
#include <ryml_std.hpp>
#include <unordered_map>
#include <string_view>
struct Prefab : public AssetBase
{
public:
static constexpr std::array<std::string_view, 1> Extensions = { ".prefab" };
public:
std::unordered_map<int64_t, ryml::Tree> Data;
public:
template <typename ParsedProject>
void Parse(ParsedProject& project, std::string& content)
{
using ObjectTypesT = typename ParsedProject::ObjectTypes;
auto names = ObjectTypesT::get_names();
ParseSceneYaml(content, false, names, [this](std::string_view componentName, int64_t ID, ryml::Tree&& tree)
{
Data.emplace(ID, std::move(tree));
});
}
};

25
include/assets/prefab_instance.hpp
View File

@@ -1,25 +0,0 @@
#pragma once
#include "asset_base.hpp"
//struct PrefabInstanceAsset : AssetBase
//{
// AssetGUID prefabGUID;
// ryml::Tree Data{};
//};
struct PrefabAsset
{
std::filesystem::path path;
std::string name;
std::unordered_map<int64_t, ryml::Tree> Data;
};
//inline PrefabInstanceAsset ParsePrefabInstance(const ryml::ConstNodeRef& node)
//{
// PrefabInstanceAsset prefabInstance;
// prefabInstance.prefabGUID = ParseAssetGUID(node["m_SourcePrefab"]);
// // prefabInstance.Data = node;
// return prefabInstance;
//}

118
include/assets/scene.h Normal file
View File

@@ -0,0 +1,118 @@
#pragma once
#include <filesystem>
#include <string>
#include <vector>
#include <random>
#include "asset_base.hpp"
#include "type_base.hpp"
struct Scene : public AssetBase
{
public:
static constexpr std::array<std::string_view, 1> Extensions = { ".unity" };
private:
std::unordered_map<int64_t, void*> IDtoAsset;
public:
int64_t GetNewID(int64_t lastID = 0)
{
for (;; ++lastID)
{
if (IDtoAsset.find(lastID) == IDtoAsset.end())
return lastID;
}
}
template <typename ParsedProject>
void Parse(ParsedProject& project, std::string& content)
{
using ObjectTypesT = typename ParsedProject::ObjectTypes;
auto& sceneData = project.CreateSceneData(GUID);
// Create ParseContext for component parsing
ParseContext context(*this, project.Assets);
auto names = ObjectTypesT::get_names();
ParseSceneYaml(content, true, names, [&sceneData, &context](std::string_view componentName, int64_t ID, ryml::Tree&& tree)
{
sceneData.AddComponent(componentName, ID, std::move(tree), context);
});
// Link all components after parsing
LinkAssets(project);
}
template <typename ParsedProject>
void LinkAssets(ParsedProject& project)
{
using ObjectTypesT = typename ParsedProject::ObjectTypes;
auto& sceneData = project.GetSceneData(GUID);
// Build the assets map (ID -> pointer)
std::unordered_map<int64_t, TypeBase*> assetsMap;
ObjectTypesT::ForEachT([&]<typename T>() -> void
{
auto& components = sceneData.template GetComponents<T>();
for (auto& component : components)
{
assetsMap.emplace(component.ID, &component);
}
});
// Link all components
ObjectTypesT::ForEachT([&]<typename T>() -> void
{
auto& components = sceneData.template GetComponents<T>();
for (auto& component : components)
{
component.Link(assetsMap);
}
});
}
template <typename ParsedProject>
void MergeComponents(const ParsedProject& project, const Scene& otherScene)
{
using ObjectTypesT = typename ParsedProject::ObjectTypes;
auto& thisSceneData = project.GetSceneData(GUID);
auto& otherSceneData = project.GetSceneData(otherScene.GUID);
std::unordered_map<int64_t, int64_t> newIDMap{};
int64_t lastID = std::random_device{}();
ObjectTypesT::ForEachT([&]<typename T>() -> void
{
auto& thisComponents = thisSceneData.template GetComponents<T>();
auto& otherComponents = otherSceneData.template GetComponents<T>();
for (auto otherComponentCopy : otherComponents)
{
int64_t originalID = otherComponentCopy.ID;
lastID = GetNewID(lastID);
otherComponentCopy.ID = lastID;
// register the new ID to the scene
newIDMap.emplace(originalID, lastID);
// add the component to the scene
thisComponents.emplace_back(std::move(otherComponentCopy));
}
});
auto& IDMapLinked = reinterpret_cast<std::unordered_map<int64_t, TypeBase*>&>(newIDMap);
ObjectTypesT::ForEachT([&]<typename T>() -> void
{
auto& thisComponents = thisSceneData.template GetComponents<T>();
for (auto& component : thisComponents)
{
component.Link(IDMapLinked);
}
});
}
};

26
include/assets/scene.hpp
View File

@@ -1,26 +0,0 @@
#pragma once
#include <filesystem>
#include <string>
#include <vector>
#include "game_object.hpp"
#include "transform.hpp"
#include "mesh_filter.hpp"
#include "prefab_instance.hpp"
struct SceneAsset
{
public:
std::filesystem::path path;
std::string name;
std::vector<GameObjectAsset> gameObjects;
std::vector<TransformAsset> transforms;
std::vector<MeshFilterAsset> meshFilters;
// std::vector<PrefabInstanceAsset> prefabInstances;
std::unordered_map<int64_t, void*> IDtoAsset;
};

16
include/assets/scripts.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include "asset_base.hpp"
struct Scripts : public AssetBase
{
public:
static constexpr std::array<std::string_view, 1> Extensions = { ".cs" };
public:
template <typename ParsedProject>
void Parse(const ParsedProject& project, std::string& content)
{
}
}

75
include/assets/transform.hpp
View File

@@ -1,75 +0,0 @@
#pragma once
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include "asset_base.hpp"
struct GameObjectAsset;
struct TransformAsset : public AssetBase
{
glm::quat Rotation;
glm::vec3 Position;
glm::vec3 Scale;
glm::mat4 GlobalMatrix;
GameObjectAsset* GameObject{ nullptr };
std::vector<TransformAsset*> Children;
TransformAsset* Parent{ nullptr };
};
inline glm::vec3 ParseVector3(const ryml::ConstNodeRef& node)
{
glm::vec3 vector;
node["x"] >> vector.x;
node["y"] >> vector.y;
node["z"] >> vector.z;
return vector;
}
inline glm::quat ParseQuaternion(const ryml::ConstNodeRef& node)
{
glm::quat quaternion;
node["x"] >> quaternion.x;
node["y"] >> quaternion.y;
node["z"] >> quaternion.z;
node["w"] >> quaternion.w;
return quaternion;
}
inline TransformAsset ParseTransform(const ryml::ConstNodeRef& node)
{
TransformAsset transform;
transform.Rotation = ParseQuaternion(node["m_LocalRotation"]);
transform.Position = ParseVector3(node["m_LocalPosition"]);
transform.Scale = ParseVector3(node["m_LocalScale"]);
transform.Parent = ParseAssetRef<TransformAsset>(node["m_Father"]);
transform.GameObject = ParseAssetRef<GameObjectAsset>(node["m_GameObject"]);
auto children = node["m_Children"];
for (const auto& child : children)
{
transform.Children.push_back(ParseAssetRef<TransformAsset>(child));
}
return transform;
}
inline void LinkTransform(const std::unordered_map<int64_t, AssetBase*>& assetsMap, TransformAsset& transform)
{
LinkAssetRef<TransformAsset>(assetsMap, transform.Parent);
for (int i = static_cast<int>(transform.Children.size()) - 1; i >= 0; i--)
{
if (!LinkAssetRef<TransformAsset>(assetsMap, transform.Children[i]))
{
std::swap(transform.Children[i], transform.Children.back());
transform.Children.pop_back();
}
}
LinkAssetRef<GameObjectAsset>(assetsMap, transform.GameObject);
}

6
include/configs/achievements.h
View File

@@ -34,8 +34,8 @@ struct Achievement
};
// Achievements configuration functions
bool loadAchievementsFromXML(const std::string& filepath);
const Achievement* getAchievementById(uint16_t id);
const std::unordered_map<uint16_t, Achievement>& getAllAchievements();
bool loadAchievementsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Achievement>& achievements);
const Achievement* getAchievementById(uint16_t id, const std::unordered_map<uint16_t, Achievement>& achievements);
const std::unordered_map<uint16_t, Achievement>& getAllAchievements(const std::unordered_map<uint16_t, Achievement>& achievements);
} // namespace cursebreaker

6
include/configs/harvestables.h
View File

@@ -34,8 +34,8 @@ struct Harvestable
};
// Harvestables configuration functions
bool loadHarvestablesFromXML(const std::string& filepath);
const Harvestable* getHarvestableById(uint16_t id);
const std::unordered_map<uint16_t, Harvestable>& getAllHarvestables();
bool loadHarvestablesFromXML(const std::string& filepath, std::unordered_map<uint16_t, Harvestable>& harvestables);
const Harvestable* getHarvestableById(uint16_t id, const std::unordered_map<uint16_t, Harvestable>& harvestables);
const std::unordered_map<uint16_t, Harvestable>& getAllHarvestables(const std::unordered_map<uint16_t, Harvestable>& harvestables);
} // namespace cursebreaker

0
include/helpers.hpp → include/configs/helpers.h
View File

6
include/configs/items.h
View File

@@ -63,8 +63,8 @@ struct Item {
};
// Items configuration functions
bool loadItemsFromXML(const std::string& filepath);
const Item* getItemById(uint16_t id);
const std::unordered_map<uint16_t, Item>& getAllItems();
bool loadItemsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Item>& items);
const Item* getItemById(uint16_t id, const std::unordered_map<uint16_t, Item>& items);
const std::unordered_map<uint16_t, Item>& getAllItems(const std::unordered_map<uint16_t, Item>& items);
} // namespace cursebreaker

6
include/configs/loot.h
View File

@@ -31,8 +31,8 @@ struct LootTable
};
// Loot configuration functions
bool loadLootTablesFromXML(const std::string& filepath);
const LootTable* getLootTableById(uint16_t id);
const std::unordered_map<uint16_t, LootTable>& getAllLootTables();
bool loadLootTablesFromXML(const std::string& filepath, std::unordered_map<uint16_t, LootTable>& lootTables);
const LootTable* getLootTableById(uint16_t id, const std::unordered_map<uint16_t, LootTable>& lootTables);
const std::unordered_map<uint16_t, LootTable>& getAllLootTables(const std::unordered_map<uint16_t, LootTable>& lootTables);
} // namespace cursebreaker

6
include/configs/npcs.h
View File

@@ -36,8 +36,8 @@ struct NPC
};
// NPCs configuration functions
bool loadNPCsFromXML(const std::string& filepath);
const NPC* getNPCById(uint16_t id);
const std::unordered_map<uint16_t, NPC>& getAllNPCs();
bool loadNPCsFromXML(const std::string& filepath, std::unordered_map<uint16_t, NPC>& npcs);
const NPC* getNPCById(uint16_t id, const std::unordered_map<uint16_t, NPC>& npcs);
const std::unordered_map<uint16_t, NPC>& getAllNPCs(const std::unordered_map<uint16_t, NPC>& npcs);
} // namespace cursebreaker

6
include/configs/shops.h
View File

@@ -31,8 +31,8 @@ struct Shop
};
// Shops configuration functions
bool loadShopsFromXML(const std::string& filepath);
const Shop* getShopById(uint16_t id);
const std::unordered_map<uint16_t, Shop>& getAllShops();
bool loadShopsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Shop>& shops);
const Shop* getShopById(uint16_t id, const std::unordered_map<uint16_t, Shop>& shops);
const std::unordered_map<uint16_t, Shop>& getAllShops(const std::unordered_map<uint16_t, Shop>& shops);
} // namespace cursebreaker

302
include/project_parser.h
View File

@@ -5,53 +5,295 @@
#include <filesystem>
#include <fstream>
#include <unordered_map>
#include <string_view>
#include <functional>
#include <span>
#include <bitset>
#include <type_traits>
#include <SQLiteCpp/SQLiteCpp.h>
#include <nlohmann/json.hpp>
#include <ryml.hpp>
#include <ryml_std.hpp>
#include "assets/asset_base.hpp"
#include "assets/scene.hpp"
#include "type_base.hpp"
#include "assets/scene.h"
#include "configs/items.h"
#include "configs/loot.h"
#include "configs/harvestables.h"
#include "configs/npcs.h"
#include "configs/shops.h"
#include "configs/achievements.h"
#include "types/prefab_instance.h"
struct AssetPath
{
std::filesystem::path path{};
AssetGUID GUID{};
};
namespace cursebreaker {
struct ParsedProject
#include "type_info.hpp"
#include "asset_base.hpp"
// Forward declarations for ForEachObj
struct GameObject;
struct Transform;
class ParsedProjectBase
{
public:
std::filesystem::path m_projectRoot;
std::vector<AssetPath> m_scriptFiles;
std::vector<AssetPath> m_imageFiles;
std::vector<AssetPath> m_meshFiles;
std::vector<AssetPath> m_sceneFiles;
std::vector<AssetPath> m_prefabFiles;
public:
ParsedProjectBase(const std::filesystem::path& projectRoot) : m_projectRoot{ projectRoot } {}
bool HasAssetType(std::string_view name) { return std::find(m_assetNames.begin(), m_assetNames.end(), name) != m_assetNames.end(); }
bool HasMonobehaviourType(std::string_view name) { return std::find(m_monobehaviourNames.begin(), m_monobehaviourNames.end(), name) != m_monobehaviourNames.end(); }
bool HasUnityType(std::string_view name) { return std::find(m_unityNames.begin(), m_unityNames.end(), name) != m_unityNames.end(); }
std::vector<PrefabAsset> m_prefabAssets;
std::vector<SceneAsset> m_sceneAssets;
protected:
std::vector<std::string_view> m_assetNames;
std::vector<std::string_view> m_monobehaviourNames;
std::vector<std::string_view> m_unityNames;
std::unordered_map<AssetGUID, PrefabAsset*> m_prefabsMap;
std::unordered_map<AssetGUID, uint32_t> m_scriptToClassHash;
std::unordered_map<uint16_t, Item> m_items;
std::unordered_map<uint16_t, LootTable> m_lootTables;
std::unordered_map<uint16_t, Harvestable> m_harvestables;
std::unordered_map<uint16_t, NPC> m_npcs;
std::unordered_map<uint16_t, Shop> m_shops;
std::unordered_map<uint16_t, Achievement> m_achievements;
public:
AssetCollectionBase* AssetsInterface;
};
void ParseProject(const std::filesystem::path& projectRoot);
template <
typename UnityTypes = TypeCollection<>,
typename MonobehaviourTypes = TypeCollection<>
>
class SceneData final
{
public:
using UnityTypesT = UnityTypes;
using MonobehaviourTypesT = MonobehaviourTypes;
using AllTypes = typename UnityTypes::template MergeWith<MonobehaviourTypes>;
using AllTypesContainer = typename AllTypes::template AsContainedType<std::vector>;
extern ParsedProject g_parsedProject;
private:
AllTypesContainer m_Data{};
public:
void AddComponent(std::string_view ComponentName, int64_t ID, ryml::Tree&& tree, ParseContext& context)
{
auto it = AddObjectFunctions.find(ComponentName);
assert(it != AddObjectFunctions.end());
auto nodeRef = tree.rootref();
it->second(static_cast<void*>(&m_Data), static_cast<const void*>(&nodeRef), ID, static_cast<void*>(&context));
}
template <typename T>
const std::vector<T>& GetComponents() const
{
return std::get<std::vector<T>>(m_Data);
}
template <typename T>
std::vector<T>& GetComponents()
{
return std::get<std::vector<T>>(m_Data);
}
/**
* Iterate over all GameObjects that have ALL of the specified component types.
*
* This function uses a bitset-based component mask for efficient filtering,
* only checking components on GameObjects that have all required types.
*
* Usage:
* sceneData.ForEachObj<Transform>([](GameObject& go, Transform& t) { ... });
* sceneData.ForEachObj<Transform, MeshFilter>([](GameObject& go, Transform& t, MeshFilter& m) { ... });
*
* @tparam ComponentTypes The component types to filter by
* @param func Lambda/function taking GameObject reference followed by references to the specified component types
*/
template <typename... ComponentTypes, typename Func>
void ForEachObj(Func&& func)
{
ForEachObjImpl<ComponentTypes...>(*this, std::forward<Func>(func));
}
/**
* Iterate over all GameObjects that have ALL of the specified component types (const version).
*
* @tparam ComponentTypes The component types to filter by
* @param func Lambda/function taking const GameObject reference followed by const references to the specified component types
*/
template <typename... ComponentTypes, typename Func>
void ForEachObj(Func&& func) const
{
ForEachObjImpl<ComponentTypes...>(*this, std::forward<Func>(func));
}
private:
// Helper implementation for ForEachObj that works with both const and non-const
template <typename... ComponentTypes, typename SceneDataRef, typename Func>
static void ForEachObjImpl(SceneDataRef&& sceneData, Func&& func)
{
static_assert(sizeof...(ComponentTypes) > 0, "At least one component type must be specified");
// Build the required component mask
std::bitset<64> requiredMask;
((requiredMask.set(AllTypes::template GetTypeIndex<ComponentTypes>())), ...);
// Get the GameObjects vector (const or non-const depending on sceneData)
auto& gameObjects = sceneData.template GetComponents<GameObject>();
// Iterate through all game objects
for (auto& gameObject : gameObjects)
{
// Check if this GameObject has all required components
if ((gameObject.ComponentMask & requiredMask) == requiredMask)
{
// Use conditional const for pointer types based on whether sceneData is const
using GameObjectT = std::remove_reference_t<decltype(gameObject)>;
using TransformPtrT = std::conditional_t<std::is_const_v<GameObjectT>,
const Transform*, Transform*>;
// Extract the components
std::tuple<std::conditional_t<std::is_const_v<GameObjectT>,
const ComponentTypes*, ComponentTypes*>...> components;
bool allFound = true;
// Try to extract each required component type
([&]()
{
using ComponentPtrT = std::conditional_t<std::is_const_v<GameObjectT>,
const ComponentTypes*, ComponentTypes*>;
if constexpr (std::is_same_v<ComponentTypes, Transform>)
{
std::get<ComponentPtrT>(components) = gameObject.transform;
if (!gameObject.transform) allFound = false;
}
else
{
ComponentPtrT found = nullptr;
for (auto* comp : gameObject.Components)
{
if (comp && comp->TypeID == AllTypes::template GetTypeIndex<ComponentTypes>())
{
found = static_cast<ComponentPtrT>(comp);
break;
}
}
std::get<ComponentPtrT>(components) = found;
if (!found) allFound = false;
}
}(), ...);
// If all components were found, call the function with GameObject first, then components
if (allFound)
{
std::apply([&](auto*... comps)
{
func(gameObject, *comps...);
}, components);
}
}
}
}
using AddObjectFunctionT = void*(*)(void*, const void*, int64_t, void*);
static auto GetAddObjectFunctions()
{
std::unordered_map<std::string_view, AddObjectFunctionT> functions;
AllTypes::ForEachT([&functions]<typename T>()
{
functions[type_name<T>()] = +[](void* pSceneData, const void* pComponentYaml, int64_t ID, void* pContext) -> void*
{
SceneData& sceneData = *static_cast<SceneData*>(pSceneData);
const ryml::ConstNodeRef& componentYaml = *static_cast<const ryml::ConstNodeRef*>(pComponentYaml);
ParseContext& context = *static_cast<ParseContext*>(pContext);
T component{};
component.ID = ID;
component.TypeID = AllTypes::template GetTypeIndex<T>(); // Set the TypeID for bitset operations
// Parse the component with context
component.Parse(componentYaml.child(0).child(0), context);
return &std::get<std::vector<T>>(sceneData.m_Data).emplace_back(std::move(component));
};
});
return functions;
}
private:
inline static std::unordered_map<std::string_view, AddObjectFunctionT> AddObjectFunctions = GetAddObjectFunctions();
};
template <
typename UnityTypes = TypeCollection<>,
typename MonobehaviourTypes = TypeCollection<>,
typename AssetTypes = TypeCollection<>
>
class ParsedProject final : public ParsedProjectBase
{
public:
using UnityTypesT = UnityTypes;
using MonobehaviourTypesT = MonobehaviourTypes;
using AssetTypesT = AssetTypes;
using ObjectTypes = typename UnityTypes::template MergeWith<MonobehaviourTypes>;
using AllTypes = typename UnityTypes::template MergeWith<MonobehaviourTypes>;
public:
AssetCollection<AssetTypes> Assets;
private:
std::unordered_map<AssetGUID, SceneData<UnityTypes, MonobehaviourTypes>> m_sceneData;
public:
ParsedProject(const std::filesystem::path& projectRoot) : ParsedProjectBase(projectRoot)
{
auto asset_names = AssetTypes::get_names();
m_assetNames.assign(asset_names.begin(), asset_names.end());
auto monobehaviour_names = MonobehaviourTypes::get_names();
m_monobehaviourNames.assign(monobehaviour_names.begin(), monobehaviour_names.end());
auto unity_names = UnityTypes::get_names();
m_unityNames.assign(unity_names.begin(), unity_names.end());
Assets = AssetCollectionBase{ asset_names };
AssetsInterface = &Assets;
}
auto& CreateSceneData(AssetGUID guid)
{
return m_sceneData[guid];
}
auto& GetSceneData(AssetGUID guid)
{
auto it = m_sceneData.find(guid);
assert(it != m_sceneData.end());
return it->second;
}
auto& GetSceneData(AssetGUID guid) const
{
auto it = m_sceneData.find(guid);
assert(it != m_sceneData.end());
return it->second;
}
template <typename Asset>
std::unordered_map<AssetGUID, Asset>& GetAssets() { return std::get<std::unordered_map<AssetGUID, Asset>>(Assets); }
template <typename Asset>
const std::unordered_map<AssetGUID, Asset>& GetAssets() const { return std::get<std::unordered_map<AssetGUID, Asset>>(Assets); }
template <typename Function>
void ForEachAsset(Function func)
{
AssetTypes::ForEachT([&]<typename T>() {
func(GetAssets<T>());
});
}
};
AssetGUID GetAssetGUIDFromFile(const std::filesystem::path& path);
void ParseSceneYaml(std::string& content, bool in_place, std::span<std::string_view> assetNames = {}, std::function<void(std::string_view, int64_t, ryml::Tree&&)> callback = {});
} // namespace cursebreaker

77
include/project_parser.hpp Normal file
View File

@@ -0,0 +1,77 @@
#pragma once
#include "project_parser.h"
template <typename AssetTypes = TypeCollection<>>
auto FindAssetFiles(std::string_view project_root)
{
using AssetsContainer = typename AssetTypes::template AsContainedType<unordered_map_guid>;
AssetsContainer Assets{};
for (const auto& entry : std::filesystem::recursive_directory_iterator(project_root))
{
if (entry.is_directory()) continue;
std::string extension = entry.path().extension().string();
if (extension == std::string_view(".meta")) continue;
AssetTypes::ForEachT([&Assets, &extension, &entry]<typename AssetT>()
{
constexpr auto assetExtensions = AssetT::Extensions;
for (auto assetExtension : assetExtensions)
{
if (extension == assetExtension)
{
static_assert(std::is_base_of_v<AssetBase, AssetT>, "Asset Type must derive from AssetBase");
AssetT asset{};
asset.Path = entry.path();
asset.GUID = GetAssetGUIDFromFile(entry.path().string() + ".meta");
std::get<std::unordered_map<AssetGUID, AssetT>>(Assets).emplace(asset.GUID, std::move(asset));
return;
}
}
});
}
return Assets;
}
template <typename AssetTypes = TypeCollection<>, typename ProjectType>
void InitializeAssetFiles(ProjectType& project)
{
AssetTypes::ForEachT([&project]<typename AssetT>()
{
std::string buffer{};
auto& assetMap = std::get<std::unordered_map<AssetGUID, AssetT>>(project.Assets);
for (auto& [guid, asset] : assetMap)
{
buffer.clear();
std::ifstream file(asset.Path);
buffer.assign(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
asset.Parse(project, buffer);
}
});
}
template <
typename AssetTypes = TypeCollection<>,
typename UnityTypes = TypeCollection<>,
typename MonobehaviourTypes = TypeCollection<>
>
ParsedProject<UnityTypes, MonobehaviourTypes, AssetTypes> ParseProject(const std::filesystem::path& projectRoot)
{
auto project = ParsedProject<UnityTypes, MonobehaviourTypes, AssetTypes>{projectRoot};
project.Assets = FindAssetFiles<AssetTypes>(projectRoot.generic_string());
InitializeAssetFiles<AssetTypes>(project);
return project;
}

39
include/tree_builder.h
View File

@@ -1,5 +1,34 @@
#pragma once
#include "assets/scene.hpp"
void BuildTree(SceneAsset& sceneAsset);
#pragma once
#include "assets/scene.h"
#include "types/transform.h"
#include <vector>
void BuildTreeHelper(Transform& transform, const glm::mat4& parentMatrix);
template <typename ParsedProject>
void BuildTree(ParsedProject& project, Scene& scene)
{
// Get the scene data which contains the components
auto& sceneData = project.GetSceneData(scene.GUID);
// Get all transforms from the scene data
auto& transforms = sceneData.template GetComponents<Transform>();
// Find transforms with no parent (root transforms)
std::vector<Transform*> rootTransforms;
for (auto& transform : transforms)
{
if (transform.Parent == nullptr)
{
rootTransforms.push_back(&transform);
}
}
// Build tree for each root transform
for (auto rootTransform : rootTransforms)
{
BuildTreeHelper(*rootTransform, glm::mat4(1.0f));
}
}

56
include/type_base.hpp Normal file
View File

@@ -0,0 +1,56 @@
#pragma once
#include <cstdint>
#include <unordered_map>
#include <array>
#include <string_view>
#include <span>
#include <ryml.hpp>
#include <ryml_std.hpp>
#include <c4/format.hpp>
#include "asset_base.hpp"
// Forward declarations
struct Scene;
struct TypeBase
{
public:
int64_t ID;
int32_t TypeID{ -1 }; // Runtime type identification for bitset operations
};
struct ParseContext
{
template <typename AssetsT>
ParseContext(Scene& mainScene, AssetsT& assets)
: MainScene(mainScene)
, Assets(&assets)
{}
Scene& MainScene;
AssetCollectionBase& Assets;
};
template <typename T>
bool LinkObjectRef(const std::unordered_map<int64_t, TypeBase*>& assetsMap, T*& asset)
{
auto it = assetsMap.find(reinterpret_cast<int64_t>(asset));
if (it != assetsMap.end())
{
asset = reinterpret_cast<T*>(it->second);
return true;
}
asset = nullptr;
return false;
}
template <typename T>
T* ParseObjectRef(const ryml::ConstNodeRef& node)
{
T* asset;
node["fileID"] >> asset;
return asset;
}

107
include/type_info.hpp Normal file
View File

@@ -0,0 +1,107 @@
#pragma once
/*
* Get the type name of a template parameter
*/
template<typename T>
consteval std::string_view type_name() {
#if defined(__clang__) || defined(__GNUC__)
constexpr std::string_view full = __PRETTY_FUNCTION__;
constexpr std::string_view prefix = "std::string_view type_name() [T = ";
constexpr std::string_view suffix = "]";
#elif defined(_MSC_VER)
constexpr std::string_view full = __FUNCSIG__;
constexpr std::string_view prefix = "class std::basic_string_view<char,struct std::char_traits<char> > __cdecl type_name<";
constexpr std::string_view suffix = ">(void)";
#endif
constexpr auto start = full.find(prefix) + prefix.size();
constexpr auto end = full.rfind(suffix);
constexpr std::string_view raw_name = full.substr(start, end - start);
// Remove "class " or "struct " prefix
constexpr std::string_view class_prefix = "class ";
constexpr std::string_view struct_prefix = "struct ";
constexpr std::string_view without_keyword =
raw_name.starts_with(class_prefix) ? raw_name.substr(class_prefix.size()) :
raw_name.starts_with(struct_prefix) ? raw_name.substr(struct_prefix.size()) :
raw_name;
// Remove namespace - keep only the part after the last "::"
constexpr auto last_colon = without_keyword.rfind("::");
constexpr std::string_view final_name =
(last_colon != std::string_view::npos)
? without_keyword.substr(last_colon + 2)
: without_keyword;
return final_name;
}
template <typename ... Ts>
struct TypeCollection
{
using Tuple = std::tuple<Ts...>;
template <typename ... OtherTs>
using Merge = TypeCollection<Ts..., OtherTs...>;
template <typename OtherTypeCollection>
struct MergeWithImpl;
template <typename ... OtherTs>
struct MergeWithImpl<TypeCollection<OtherTs...>>
{
using type = TypeCollection<Ts..., OtherTs...>;
};
template <typename OtherTypeCollection>
using MergeWith = typename MergeWithImpl<OtherTypeCollection>::type;
template <template <typename> typename ContainerType>
using AsContainedType = std::tuple<ContainerType<Ts>...>;
static constexpr std::array<std::string_view, sizeof...(Ts)> get_names()
{
return std::array<std::string_view, sizeof...(Ts)>{ type_name<Ts>()... };
}
static constexpr bool has_duplicate_names()
{
constexpr auto names = get_names();
for (size_t i = 0; i < names.size(); i++)
for (size_t j = i + 1; j < names.size(); j++)
if (names[i] == names[j])
return true;
return false;
}
// check for duplicates
static_assert(!has_duplicate_names());
template <typename Func>
static constexpr void ForEachT(Func&& func)
{
(func.template operator()<Ts>(), ...);
}
template <typename T>
static constexpr bool HasT()
{
return (std::is_same_v<T, Ts> || ...);
}
// Get the index of a type in the collection
template <typename T>
static constexpr int32_t GetTypeIndex()
{
int32_t index = 0;
bool found = false;
((std::is_same_v<T, Ts> ? (found = true, false) : (found ? false : (++index, false))), ...);
return found ? index : -1;
}
// Get the type index at runtime by comparing type IDs
static constexpr size_t Count() { return sizeof...(Ts); }
};

11
include/types/Interactable_resource.h Normal file
View File

@@ -0,0 +1,11 @@
#pragma once
#include "type_base.hpp"
struct Interactable_Resource : public TypeBase
{
uint16_t ResourceID;
void Parse(const ryml::ConstNodeRef& node, ParseContext& context);
void Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap) {};
};

65
include/types/game_object.h Normal file
View File

@@ -0,0 +1,65 @@
#pragma once
#include <string>
#include <vector>
#include <bitset>
#include <ryml_std.hpp>
#include "type_base.hpp"
#include "transform.h"
struct GameObject : public TypeBase
{
std::string name;
uint8_t layer{ 0 };
uint8_t namMeshLayer{ 0 };
std::string tag;
Transform* transform{ nullptr };
std::vector<TypeBase*> Components;
/**
* ComponentMask is a bitset where each bit corresponds to a component type index.
* This allows for extremely fast checking of whether a GameObject has specific components.
* The bit is set during the Link() phase when components are resolved.
* Max 64 different component types are supported.
*/
std::bitset<64> ComponentMask;
void Parse(const ryml::ConstNodeRef& node, ParseContext& context);
void Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap);
// Check if this GameObject has a specific component type
template <typename T>
bool HasComponent() const
{
// Type index must be set by the system
for (auto* comp : Components)
{
if (comp && comp->TypeID >= 0 && comp->TypeID < 64)
{
if (ComponentMask.test(comp->TypeID))
{
// Additional runtime check could be added here
return true;
}
}
}
return false;
}
// Get a component of a specific type
template <typename T>
T* GetComponent()
{
for (auto* comp : Components)
{
if (auto* typedComp = dynamic_cast<T*>(comp))
{
return typedComp;
}
}
return nullptr;
}
};

18
include/types/mesh_filter.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#include <string>
#include "type_base.hpp"
struct GameObject;
struct MeshFilter : TypeBase
{
AssetGUID Mesh;
GameObject* GameObject{ nullptr };
void Parse(const ryml::ConstNodeRef& node, ParseContext& context);
void Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap);
};

13
include/types/prefab_instance.h Normal file
View File

@@ -0,0 +1,13 @@
#pragma once
#include "type_base.hpp"
struct PrefabInstance : public TypeBase
{
public:
void Parse(const ryml::ConstNodeRef& node, ParseContext& context);
void Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap) {};
public:
std::unordered_map<int64_t, ryml::Tree> Data;
};

27
include/types/transform.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include "type_base.hpp"
struct GameObject;
struct Transform : public TypeBase
{
glm::quat Rotation;
glm::vec3 Position;
glm::vec3 Scale;
glm::mat4 GlobalMatrix;
GameObject* GameObject{ nullptr };
std::vector<Transform*> Children;
Transform* Parent{ nullptr };
void Parse(const ryml::ConstNodeRef& node, ParseContext& context);
void Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap);
};

3
src/assets/prefab.cpp Normal file
View File

@@ -0,0 +1,3 @@
#include "assets/prefab.h"
#include "project_parser.h"

26
src/configs/achievements.cpp
View File

@@ -1,6 +1,6 @@
#include "configs/achievements.h"
#include "project_parser.h"
#include "helpers.hpp"
#include "configs/helpers.h"
#include <iostream>
namespace cursebreaker {
@@ -9,10 +9,10 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseAchievement(tinyxml2::XMLElement* achievementElement);
static void parseAchievement(tinyxml2::XMLElement* achievementElement, std::unordered_map<uint16_t, Achievement>& achievements);
static void parseRequirements(tinyxml2::XMLElement* achievementElement, Achievement& achievement);
bool loadAchievementsFromXML(const std::string& filepath) {
bool loadAchievementsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Achievement>& achievements) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -27,20 +27,20 @@ bool loadAchievementsFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_achievements.clear();
achievements.clear();
// Parse all achievements
for (tinyxml2::XMLElement* achievementElement = root->FirstChildElement("achievement");
achievementElement != nullptr;
achievementElement = achievementElement->NextSiblingElement("achievement")) {
parseAchievement(achievementElement);
parseAchievement(achievementElement, achievements);
}
std::cout << "Loaded " << g_parsedProject.m_achievements.size() << " achievements from XML" << std::endl;
std::cout << "Loaded " << achievements.size() << " achievements from XML" << std::endl;
return true;
}
void parseAchievement(tinyxml2::XMLElement* achievementElement) {
void parseAchievement(tinyxml2::XMLElement* achievementElement, std::unordered_map<uint16_t, Achievement>& achievements) {
Achievement achievement;
// Parse basic attributes
@@ -56,7 +56,7 @@ void parseAchievement(tinyxml2::XMLElement* achievementElement) {
// Parse child elements
parseRequirements(achievementElement, achievement);
g_parsedProject.m_achievements[achievement.id] = std::move(achievement);
achievements[achievement.id] = std::move(achievement);
}
void parseRequirements(tinyxml2::XMLElement* achievementElement, Achievement& achievement) {
@@ -74,13 +74,13 @@ void parseRequirements(tinyxml2::XMLElement* achievementElement, Achievement& ac
}
}
const Achievement* getAchievementById(uint16_t id) {
auto it = g_parsedProject.m_achievements.find(id);
return (it != g_parsedProject.m_achievements.end()) ? &it->second : nullptr;
const Achievement* getAchievementById(uint16_t id, const std::unordered_map<uint16_t, Achievement>& achievements) {
auto it = achievements.find(id);
return (it != achievements.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, Achievement>& getAllAchievements() {
return g_parsedProject.m_achievements;
const std::unordered_map<uint16_t, Achievement>& getAllAchievements(const std::unordered_map<uint16_t, Achievement>& achievements) {
return achievements;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

26
src/configs/harvestables.cpp
View File

@@ -1,6 +1,6 @@
#include "configs/harvestables.h"
#include "project_parser.h"
#include "helpers.hpp"
#include "configs/helpers.h"
#include <iostream>
#include <sstream>
#include <algorithm>
@@ -11,10 +11,10 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseHarvestable(tinyxml2::XMLElement* harvestableElement);
static void parseHarvestable(tinyxml2::XMLElement* harvestableElement, std::unordered_map<uint16_t, Harvestable>& harvestables);
static void parseLoot(tinyxml2::XMLElement* harvestableElement, Harvestable& harvestable);
bool loadHarvestablesFromXML(const std::string& filepath) {
bool loadHarvestablesFromXML(const std::string& filepath, std::unordered_map<uint16_t, Harvestable>& harvestables) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -29,20 +29,20 @@ bool loadHarvestablesFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_harvestables.clear();
harvestables.clear();
// Parse all harvestables
for (tinyxml2::XMLElement* harvestableElement = root->FirstChildElement("harvestable");
harvestableElement != nullptr;
harvestableElement = harvestableElement->NextSiblingElement("harvestable")) {
parseHarvestable(harvestableElement);
parseHarvestable(harvestableElement, harvestables);
}
std::cout << "Loaded " << g_parsedProject.m_harvestables.size() << " harvestables from XML" << std::endl;
std::cout << "Loaded " << harvestables.size() << " harvestables from XML" << std::endl;
return true;
}
void parseHarvestable(tinyxml2::XMLElement* harvestableElement) {
void parseHarvestable(tinyxml2::XMLElement* harvestableElement, std::unordered_map<uint16_t, Harvestable>& harvestables) {
Harvestable harvestable;
// Parse basic attributes
@@ -58,7 +58,7 @@ void parseHarvestable(tinyxml2::XMLElement* harvestableElement) {
// Parse child elements
parseLoot(harvestableElement, harvestable);
g_parsedProject.m_harvestables[harvestable.id] = std::move(harvestable);
harvestables[harvestable.id] = std::move(harvestable);
}
void parseLoot(tinyxml2::XMLElement* harvestableElement, Harvestable& harvestable) {
@@ -75,13 +75,13 @@ void parseLoot(tinyxml2::XMLElement* harvestableElement, Harvestable& harvestabl
}
}
const Harvestable* getHarvestableById(uint16_t id) {
auto it = g_parsedProject.m_harvestables.find(id);
return (it != g_parsedProject.m_harvestables.end()) ? &it->second : nullptr;
const Harvestable* getHarvestableById(uint16_t id, const std::unordered_map<uint16_t, Harvestable>& harvestables) {
auto it = harvestables.find(id);
return (it != harvestables.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, Harvestable>& getAllHarvestables() {
return g_parsedProject.m_harvestables;
const std::unordered_map<uint16_t, Harvestable>& getAllHarvestables(const std::unordered_map<uint16_t, Harvestable>& harvestables) {
return harvestables;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

2
src/helpers.cpp → src/configs/helpers.cpp
View File

@@ -1,4 +1,4 @@
#include "helpers.hpp"
#include "configs/helpers.h"
namespace cursebreaker {

26
src/configs/items.cpp
View File

@@ -1,6 +1,6 @@
#include "configs/items.h"
#include "project_parser.h"
#include "helpers.hpp"
#include "configs/helpers.h"
#include <iostream>
#include <unordered_map>
#include <sstream>
@@ -12,11 +12,11 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseItem(tinyxml2::XMLElement* itemElement);
static void parseItem(tinyxml2::XMLElement* itemElement, std::unordered_map<uint16_t, Item>& items);
static void parseStats(tinyxml2::XMLElement* itemElement, Item& item);
static void parseCraftings(tinyxml2::XMLElement* itemElement, Item& item);
bool loadItemsFromXML(const std::string& filepath) {
bool loadItemsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Item>& items) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -31,20 +31,20 @@ bool loadItemsFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_items.clear();
items.clear();
// Parse all items
for (tinyxml2::XMLElement* itemElement = root->FirstChildElement("item");
itemElement != nullptr;
itemElement = itemElement->NextSiblingElement("item")) {
parseItem(itemElement);
parseItem(itemElement, items);
}
std::cout << "Loaded " << g_parsedProject.m_items.size() << " items from XML" << std::endl;
std::cout << "Loaded " << items.size() << " items from XML" << std::endl;
return true;
}
void parseItem(tinyxml2::XMLElement* itemElement) {
void parseItem(tinyxml2::XMLElement* itemElement, std::unordered_map<uint16_t, Item>& items) {
Item item;
// Parse basic attributes
@@ -79,7 +79,7 @@ void parseItem(tinyxml2::XMLElement* itemElement) {
parseStats(itemElement, item);
parseCraftings(itemElement, item);
g_parsedProject.m_items[item.id] = std::move(item);
items[item.id] = std::move(item);
}
void parseStats(tinyxml2::XMLElement* itemElement, Item& item) {
@@ -157,13 +157,13 @@ void parseCraftings(tinyxml2::XMLElement* itemElement, Item& item) {
}
}
const Item* getItemById(uint16_t id) {
auto it = g_parsedProject.m_items.find(id);
return (it != g_parsedProject.m_items.end()) ? &it->second : nullptr;
const Item* getItemById(uint16_t id, const std::unordered_map<uint16_t, Item>& items) {
auto it = items.find(id);
return (it != items.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, Item>& getAllItems() {
return g_parsedProject.m_items;
const std::unordered_map<uint16_t, Item>& getAllItems(const std::unordered_map<uint16_t, Item>& items) {
return items;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

25
src/configs/loot.cpp
View File

@@ -1,5 +1,6 @@
#include "configs/loot.h"
#include "project_parser.h"
#include "configs/helpers.h"
#include <iostream>
namespace cursebreaker {
@@ -8,10 +9,10 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseLootTable(tinyxml2::XMLElement* lootTableElement);
static void parseLootTable(tinyxml2::XMLElement* lootTableElement, std::unordered_map<uint16_t, LootTable>& lootTables);
static void parseEntries(tinyxml2::XMLElement* lootTableElement, LootTable& lootTable);
bool loadLootTablesFromXML(const std::string& filepath) {
bool loadLootTablesFromXML(const std::string& filepath, std::unordered_map<uint16_t, LootTable>& lootTables) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -26,20 +27,20 @@ bool loadLootTablesFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_lootTables.clear();
lootTables.clear();
// Parse all loot tables
for (tinyxml2::XMLElement* lootTableElement = root->FirstChildElement("lootTable");
lootTableElement != nullptr;
lootTableElement = lootTableElement->NextSiblingElement("lootTable")) {
parseLootTable(lootTableElement);
parseLootTable(lootTableElement, lootTables);
}
std::cout << "Loaded " << g_parsedProject.m_lootTables.size() << " loot tables from XML" << std::endl;
std::cout << "Loaded " << lootTables.size() << " loot tables from XML" << std::endl;
return true;
}
void parseLootTable(tinyxml2::XMLElement* lootTableElement) {
void parseLootTable(tinyxml2::XMLElement* lootTableElement, std::unordered_map<uint16_t, LootTable>& lootTables) {
LootTable lootTable;
// Parse basic attributes
@@ -50,7 +51,7 @@ void parseLootTable(tinyxml2::XMLElement* lootTableElement) {
// Parse child elements
parseEntries(lootTableElement, lootTable);
g_parsedProject.m_lootTables[lootTable.id] = std::move(lootTable);
lootTables[lootTable.id] = std::move(lootTable);
}
void parseEntries(tinyxml2::XMLElement* lootTableElement, LootTable& lootTable) {
@@ -69,13 +70,13 @@ void parseEntries(tinyxml2::XMLElement* lootTableElement, LootTable& lootTable)
}
}
const LootTable* getLootTableById(uint16_t id) {
auto it = g_parsedProject.m_lootTables.find(id);
return (it != g_parsedProject.m_lootTables.end()) ? &it->second : nullptr;
const LootTable* getLootTableById(uint16_t id, const std::unordered_map<uint16_t, LootTable>& lootTables) {
auto it = lootTables.find(id);
return (it != lootTables.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, LootTable>& getAllLootTables() {
return g_parsedProject.m_lootTables;
const std::unordered_map<uint16_t, LootTable>& getAllLootTables(const std::unordered_map<uint16_t, LootTable>& lootTables) {
return lootTables;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

26
src/configs/npcs.cpp
View File

@@ -1,6 +1,6 @@
#include "configs/npcs.h"
#include "project_parser.h"
#include "helpers.hpp"
#include "configs/helpers.h"
#include <iostream>
#include <sstream>
#include <algorithm>
@@ -11,11 +11,11 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseNPC(tinyxml2::XMLElement* npcElement);
static void parseNPC(tinyxml2::XMLElement* npcElement, std::unordered_map<uint16_t, NPC>& npcs);
static void parseStats(tinyxml2::XMLElement* npcElement, NPC& npc);
static void parseLoot(tinyxml2::XMLElement* npcElement, NPC& npc);
bool loadNPCsFromXML(const std::string& filepath) {
bool loadNPCsFromXML(const std::string& filepath, std::unordered_map<uint16_t, NPC>& npcs) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -30,20 +30,20 @@ bool loadNPCsFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_npcs.clear();
npcs.clear();
// Parse all NPCs
for (tinyxml2::XMLElement* npcElement = root->FirstChildElement("npc");
npcElement != nullptr;
npcElement = npcElement->NextSiblingElement("npc")) {
parseNPC(npcElement);
parseNPC(npcElement, npcs);
}
std::cout << "Loaded " << g_parsedProject.m_npcs.size() << " NPCs from XML" << std::endl;
std::cout << "Loaded " << npcs.size() << " NPCs from XML" << std::endl;
return true;
}
void parseNPC(tinyxml2::XMLElement* npcElement) {
void parseNPC(tinyxml2::XMLElement* npcElement, std::unordered_map<uint16_t, NPC>& npcs) {
NPC npc;
// Parse basic attributes
@@ -63,7 +63,7 @@ void parseNPC(tinyxml2::XMLElement* npcElement) {
parseStats(npcElement, npc);
parseLoot(npcElement, npc);
g_parsedProject.m_npcs[npc.id] = std::move(npc);
npcs[npc.id] = std::move(npc);
}
void parseStats(tinyxml2::XMLElement* npcElement, NPC& npc) {
@@ -96,13 +96,13 @@ void parseLoot(tinyxml2::XMLElement* npcElement, NPC& npc) {
}
}
const NPC* getNPCById(uint16_t id) {
auto it = g_parsedProject.m_npcs.find(id);
return (it != g_parsedProject.m_npcs.end()) ? &it->second : nullptr;
const NPC* getNPCById(uint16_t id, const std::unordered_map<uint16_t, NPC>& npcs) {
auto it = npcs.find(id);
return (it != npcs.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, NPC>& getAllNPCs() {
return g_parsedProject.m_npcs;
const std::unordered_map<uint16_t, NPC>& getAllNPCs(const std::unordered_map<uint16_t, NPC>& npcs) {
return npcs;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

25
src/configs/shops.cpp
View File

@@ -1,5 +1,6 @@
#include "configs/shops.h"
#include "project_parser.h"
#include "configs/helpers.h"
#include <iostream>
namespace cursebreaker {
@@ -8,10 +9,10 @@ namespace cursebreaker {
static std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue = "");
static int getAttributeValueInt(tinyxml2::XMLElement* element, const char* attribute, int defaultValue = 0);
static bool getAttributeValueBool(tinyxml2::XMLElement* element, const char* attribute, bool defaultValue = false);
static void parseShop(tinyxml2::XMLElement* shopElement);
static void parseShop(tinyxml2::XMLElement* shopElement, std::unordered_map<uint16_t, Shop>& shops);
static void parseInventory(tinyxml2::XMLElement* shopElement, Shop& shop);
bool loadShopsFromXML(const std::string& filepath) {
bool loadShopsFromXML(const std::string& filepath, std::unordered_map<uint16_t, Shop>& shops) {
tinyxml2::XMLDocument doc;
tinyxml2::XMLError result = doc.LoadFile(filepath.c_str());
@@ -26,20 +27,20 @@ bool loadShopsFromXML(const std::string& filepath) {
return false;
}
g_parsedProject.m_shops.clear();
shops.clear();
// Parse all shops
for (tinyxml2::XMLElement* shopElement = root->FirstChildElement("shop");
shopElement != nullptr;
shopElement = shopElement->NextSiblingElement("shop")) {
parseShop(shopElement);
parseShop(shopElement, shops);
}
std::cout << "Loaded " << g_parsedProject.m_shops.size() << " shops from XML" << std::endl;
std::cout << "Loaded " << shops.size() << " shops from XML" << std::endl;
return true;
}
void parseShop(tinyxml2::XMLElement* shopElement) {
void parseShop(tinyxml2::XMLElement* shopElement, std::unordered_map<uint16_t, Shop>& shops) {
Shop shop;
// Parse basic attributes
@@ -51,7 +52,7 @@ void parseShop(tinyxml2::XMLElement* shopElement) {
// Parse child elements
parseInventory(shopElement, shop);
g_parsedProject.m_shops[shop.id] = std::move(shop);
shops[shop.id] = std::move(shop);
}
void parseInventory(tinyxml2::XMLElement* shopElement, Shop& shop) {
@@ -69,13 +70,13 @@ void parseInventory(tinyxml2::XMLElement* shopElement, Shop& shop) {
}
}
const Shop* getShopById(uint16_t id) {
auto it = g_parsedProject.m_shops.find(id);
return (it != g_parsedProject.m_shops.end()) ? &it->second : nullptr;
const Shop* getShopById(uint16_t id, const std::unordered_map<uint16_t, Shop>& shops) {
auto it = shops.find(id);
return (it != shops.end()) ? &it->second : nullptr;
}
const std::unordered_map<uint16_t, Shop>& getAllShops() {
return g_parsedProject.m_shops;
const std::unordered_map<uint16_t, Shop>& getAllShops(const std::unordered_map<uint16_t, Shop>& shops) {
return shops;
}
std::string getAttributeValue(tinyxml2::XMLElement* element, const char* attribute, const std::string& defaultValue) {

167
src/main.cpp
View File

@@ -5,8 +5,21 @@
#include <SQLiteCpp/SQLiteCpp.h>
#include "project_parser.h"
#include "project_parser.hpp"
#include "tree_builder.h"
#include "assets/scene.hpp"
// Assets
#include "assets/prefab.h"
#include "assets/scene.h"
// Unity types
#include "types/game_object.h"
#include "types/transform.h"
#include "types/prefab_instance.h"
// Custom types
#include "types/Interactable_resource.h"
#include "configs/items.h"
#include "configs/achievements.h"
#include "configs/harvestables.h"
@@ -17,80 +30,112 @@
using namespace cursebreaker;
int main() {
ParseProject("../../CBAssets/_GameAssets/");
int main()
{
using AssetTypes = TypeCollection<Prefab, Scene>;
using UnityTypes = TypeCollection<GameObject, Transform, PrefabInstance>;
using MonobehaviourTypes = TypeCollection<Interactable_Resource>;
#ifdef linux
auto projectRoot = "../../CBAssets/_GameAssets/";
#else
auto projectRoot = "../CBAssets/_GameAssets/";
#endif
auto project = ParseProject<AssetTypes, UnityTypes, MonobehaviourTypes>(projectRoot);
// build tree
for (auto& scene : g_parsedProject.m_sceneAssets)
for (auto& [guid, scene] : project.GetAssets<Scene>())
{
BuildTree(scene);
BuildTree(project, scene);
}
// Example usage of ForEachObj to iterate over GameObjects with specific components
// Iterate through all scenes and process objects with Transform components
for (auto& [guid, scene] : project.GetAssets<Scene>())
{
auto& sceneData = project.GetSceneData(guid);
// Example 1: Iterate over all objects with Transform
sceneData.ForEachObj<Transform>([&](GameObject& gameObject, Transform& transform)
{
// Process each object with a transform
std::cout << "Found object [" << gameObject.name << "] with transform at position: "
<< transform.Position.x << ", " << transform.Position.y << ", " << transform.Position.z << std::endl;
});
sceneData.ForEachObj<Transform, Interactable_Resource>([&](GameObject& gameObject, Transform& transform, Interactable_Resource& interactable)
{
std::cout << "Found object [" << gameObject.name << "] with transform at position: "
<< transform.Position.x << ", " << transform.Position.y << ", " << transform.Position.z << std::endl;
std::cout << "Found interactable resource with ID: " << interactable.ID << std::endl;
});
}
// Load configs from XML
std::string configPath = "../../CBAssets/_GameAssets/";
loadItemsFromXML(configPath + "items.xml");
loadAchievementsFromXML(configPath + "achievements.xml");
loadHarvestablesFromXML(configPath + "harvestables.xml");
loadLootTablesFromXML(configPath + "loot.xml");
loadNPCsFromXML(configPath + "npcs.xml");
loadShopsFromXML(configPath + "shops.xml");
//std::string configPath = "../../CBAssets/_GameAssets/";
//loadItemsFromXML(configPath + "items.xml");
//loadAchievementsFromXML(configPath + "achievements.xml");
//loadHarvestablesFromXML(configPath + "harvestables.xml");
//loadLootTablesFromXML(configPath + "loot.xml");
//loadNPCsFromXML(configPath + "npcs.xml");
//loadShopsFromXML(configPath + "shops.xml");
// Create in-memory database
SQLite::Database memDB(":memory:", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
//// Create in-memory database
//SQLite::Database memDB(":memory:", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
// Populate database with configs
std::vector<Item> itemsVec;
for (const auto& pair : getAllItems()) {
itemsVec.push_back(pair.second);
}
PopulateItemDB(memDB, itemsVec);
//// Populate database with configs
//std::vector<Item> itemsVec;
//for (const auto& pair : getAllItems()) {
// itemsVec.push_back(pair.second);
//}
//PopulateItemDB(memDB, itemsVec);
std::vector<Achievement> achievementsVec;
for (const auto& pair : getAllAchievements()) {
achievementsVec.push_back(pair.second);
}
PopulateAchievementDB(memDB, achievementsVec);
//std::vector<Achievement> achievementsVec;
//for (const auto& pair : getAllAchievements()) {
// achievementsVec.push_back(pair.second);
//}
//PopulateAchievementDB(memDB, achievementsVec);
std::vector<Harvestable> harvestablesVec;
for (const auto& pair : getAllHarvestables()) {
harvestablesVec.push_back(pair.second);
}
PopulateHarvestableDB(memDB, harvestablesVec);
//std::vector<Harvestable> harvestablesVec;
//for (const auto& pair : getAllHarvestables()) {
// harvestablesVec.push_back(pair.second);
//}
//PopulateHarvestableDB(memDB, harvestablesVec);
std::vector<LootTable> lootVec;
for (const auto& pair : getAllLootTables()) {
lootVec.push_back(pair.second);
}
PopulateLootDB(memDB, lootVec);
//std::vector<LootTable> lootVec;
//for (const auto& pair : getAllLootTables()) {
// lootVec.push_back(pair.second);
//}
//PopulateLootDB(memDB, lootVec);
std::vector<NPC> npcsVec;
for (const auto& pair : getAllNPCs()) {
npcsVec.push_back(pair.second);
}
PopulateNPCDB(memDB, npcsVec);
//std::vector<NPC> npcsVec;
//for (const auto& pair : getAllNPCs()) {
// npcsVec.push_back(pair.second);
//}
//PopulateNPCDB(memDB, npcsVec);
std::vector<Shop> shopsVec;
for (const auto& pair : getAllShops()) {
shopsVec.push_back(pair.second);
}
PopulateShopDB(memDB, shopsVec);
//std::vector<Shop> shopsVec;
//for (const auto& pair : getAllShops()) {
// shopsVec.push_back(pair.second);
//}
//PopulateShopDB(memDB, shopsVec);
// Save to file
{
SQLite::Database fileDB("cursebreaker.db", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
sqlite3* srcHandle = memDB.getHandle();
sqlite3* dstHandle = fileDB.getHandle();
sqlite3_backup* backup = sqlite3_backup_init(dstHandle, "main", srcHandle, "main");
if (backup) {
sqlite3_backup_step(backup, -1);
sqlite3_backup_finish(backup);
} else {
std::cerr << "Failed to initialize backup" << std::endl;
}
}
//// Save to file
//{
// SQLite::Database fileDB("cursebreaker.db", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
// sqlite3* srcHandle = memDB.getHandle();
// sqlite3* dstHandle = fileDB.getHandle();
// sqlite3_backup* backup = sqlite3_backup_init(dstHandle, "main", srcHandle, "main");
// if (backup) {
// sqlite3_backup_step(backup, -1);
// sqlite3_backup_finish(backup);
// } else {
// std::cerr << "Failed to initialize backup" << std::endl;
// }
//}
std::cout << "Database created and saved to cursebreaker.db" << std::endl;
//std::cout << "Database created and saved to cursebreaker.db" << std::endl;
return 0;
}

934
src/project_parser.cpp
View File

@@ -1,465 +1,469 @@
#include "project_parser.h"
#include <string>
#include <iostream>
#include <vector>
#include <filesystem>
#include <fstream>
#include <unordered_map>
#include <string_view>
#include <span>
#include <thread>
#include <future>
#include <mutex>
#include <atomic>
#include <chrono>
#include <regex>
#include <ranges>
#include <algorithm>
#include <random>
#include <ryml.hpp>
#include <ryml_std.hpp>
#include <c4/format.hpp>
#include "assets/asset_base.hpp"
#include "assets/game_object.hpp"
#include "assets/transform.hpp"
#include "assets/mesh_filter.hpp"
#include "assets/prefab_instance.hpp"
#include "helpers.hpp"
namespace cursebreaker {
constexpr uint32_t fnv1a_hash(const char* str, uint32_t hash = 2166136261u)
{
return (*str == '\0') ? hash : fnv1a_hash(str + 1, (hash ^ static_cast<uint32_t>(*str)) * 16777619u);
}
uint32_t fnv1a_hash(c4::csubstr substr)
{
uint32_t hash = 2166136261u;
for (const auto& c : substr)
{
hash = (hash ^ static_cast<uint32_t>(c)) * 16777619u;
}
return hash;
}
uint32_t fnv1a_hash(std::string_view substr)
{
uint32_t hash = 2166136261u;
for (const auto& c : substr)
{
hash = (hash ^ static_cast<uint32_t>(c)) * 16777619u;
}
return hash;
}
AssetGUID GetAssetGUIDFromFile(const std::filesystem::path& path)
{
/*
// read file as yaml and get "guid"
std::ifstream file(path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
try
{
ryml::Tree tree = ryml::parse_in_place(c4::substr{ content.data(), content.size() });
ryml::ConstNodeRef root = tree.crootref();
return ParseAssetGUID(root);
}
catch (const std::runtime_error& e)
{
std::cerr << "Error parsing asset GUID: " << e.what() << std::endl;
return AssetGUID{};
}
*/
// regex match the GUID from the contents of the file
static auto pattern = std::regex(R"(guid: (\w+))");
std::smatch match{};
std::ifstream file(path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
if (std::regex_search(content, match, pattern))
{
assert(match[1].length() == 32);
AssetGUID guid{ std::string_view{ &*match[1].first, static_cast<size_t>(match[1].length()) } };
return guid;
}
return AssetGUID{};
}
std::unordered_map<int64_t, ryml::Tree> ParseYamlFile(std::string& content, bool in_place)
{
std::unordered_map<int64_t, ryml::Tree> Data{};
std::string::size_type start = content.find("---", 0);
std::string::size_type end = content.find("---", start + 1);
while (end != std::string::npos)
{
auto document = std::string_view(content.data() + start, content.data() + end);
// if the document contains "stripped", skip it
auto str_view = std::string_view(document.data(), document.size());
if (str_view.find("stripped") != std::string_view::npos)
goto skip;
{
auto secondLine = str_view.find('\n') + 1;
auto classStr = std::string_view(document.data() + secondLine, str_view.find(':', secondLine) - secondLine);
uint32_t classHash = fnv1a_hash(classStr);
constexpr std::array<uint32_t, 5> availableClasses = {
fnv1a_hash("GameObject"),
fnv1a_hash("Transform"),
fnv1a_hash("MeshFilter"),
fnv1a_hash("PrefabInstance"),
fnv1a_hash("MonoBehaviour")
};
if (std::ranges::find(availableClasses, classHash) == availableClasses.end()) goto skip;
}
try
{
ryml::Tree tree{};
if (in_place)
{
tree = ryml::parse_in_place(c4::substr{ const_cast<char*>(document.data()), document.size() });
}
else
{
tree = ryml::parse_in_arena(c4::csubstr{ const_cast<char*>(document.data()), document.size() });
}
auto anchorData = tree.crootref().child(0).val_anchor();
int64_t ID{ };
auto [ptr, ec] = std::from_chars(anchorData.data(), anchorData.data() + anchorData.size(), ID);
assert(ec == std::errc{});
Data.emplace(ID, std::move(tree));
}
catch (const std::runtime_error& e)
{
std::cerr << "Error parsing scene asset: " << e.what() << std::endl;
std::cerr << std::string_view(document.data(), document.size()) << std::endl;
}
skip:;
start = end;
end = content.find("---", start + 1);
}
return Data;
}
int64_t GetNewID(const SceneAsset& scene, int64_t lastID = 0)
{
for (;; ++lastID)
{
if (scene.IDtoAsset.find(lastID) == scene.IDtoAsset.end())
return lastID;
}
}
template <typename T>
void MergeComponents(SceneAsset& scene, std::unordered_map<int64_t, int64_t>& idMap, std::vector<T>& to, const std::vector<T>& from, int64_t& lastID)
{
for (const auto& asset : from)
{
// create a copy of the asset
auto assetCopy = asset;
// get a new ID
lastID = GetNewID(scene, lastID);
assetCopy.ID = lastID;
// register the new ID to the scene
scene.IDtoAsset.emplace(assetCopy.ID, nullptr);
// add the asset to the scene
to.emplace_back(assetCopy);
}
}
void MergeScenes(SceneAsset& to, const SceneAsset& from)
{
std::unordered_map<int64_t, int64_t> newIDMap{};
// randomize the IDs to avoid conflicts
int64_t lastID = std::random_device{}();
MergeComponents(to, newIDMap, to.gameObjects, from.gameObjects, lastID);
MergeComponents(to, newIDMap, to.transforms, from.transforms, lastID);
MergeComponents(to, newIDMap, to.meshFilters, from.meshFilters, lastID);
auto& IDMapLinked = reinterpret_cast<std::unordered_map<int64_t, AssetBase*>&>(newIDMap);
for (auto& gameObject : to.gameObjects) LinkGameObject(IDMapLinked, gameObject);
for (auto& transform : to.transforms) LinkTransform(IDMapLinked, transform);
for (auto& meshFilter : to.meshFilters) LinkMeshFilter(IDMapLinked, meshFilter);
}
void ParseScene(SceneAsset& asset, const std::unordered_map<int64_t, ryml::Tree>& documents);
void InstantiatePrefab(SceneAsset& parentScene, const ryml::Tree& instance)
{
auto instanceData = instance.crootref().child(0).child(0);
// parse the prebad UID
AssetGUID prefabAssetGUID = ParseAssetGUID(instanceData["m_SourcePrefab"]);
auto prefabAssetIt = g_parsedProject.m_prefabsMap.find(prefabAssetGUID);
if (prefabAssetIt == g_parsedProject.m_prefabsMap.end())
{
std::cerr << "Prefab asset not found: " << std::endl;
return;
}
const PrefabAsset& prefabAsset = *prefabAssetIt->second;
auto prefabAssetTree = prefabAsset.Data;
// apply the modifications to the prefab asset tree
const auto& overrides = instanceData["m_Modification"]["m_Modifications"];
for (auto override : overrides)
{
int64_t ref = reinterpret_cast<int64_t>(ParseAssetRef<void>(override["target"]));
auto prefabAssetTreeIt = prefabAssetTree.find(ref);
if (prefabAssetTreeIt == prefabAssetTree.end())
{
std::cerr << "Prefab asset tree not found: " << ref << std::endl;
continue;
}
auto& targetTree = prefabAssetTreeIt->second;
const auto propertyPath{ override["propertyPath"].val() };
const auto& overrideValue = override["value"];
// Use lookup_path_or_modify to set the value at the property path
// Start from the root of the document (child(0) is the document root)
auto rootId = targetTree.crootref().child(0).id();
targetTree.lookup_path_or_modify(&instance, overrideValue.id(), propertyPath, rootId);
}
// parse the prefab asset tree into a scene
SceneAsset scene{};
ParseScene(scene, prefabAssetTree);
// get the index of the added transform
size_t addedTransformIndex = scene.transforms.size();
// merge the scenes
MergeScenes(parentScene, scene);
// find the parent transform and add a the instantiated prebab to the children
auto parentID = ParseAssetRef<TransformAsset>(instanceData["m_TransformParent"]);
scene.transforms[addedTransformIndex].Parent = parentID;
auto parentTransform = std::find_if(scene.transforms.begin(), scene.transforms.end(), [parentID](const TransformAsset& asset)
{
return asset.ID == reinterpret_cast<int64_t>(parentID);
});
if (parentTransform != scene.transforms.end())
{
parentTransform->Children.push_back(reinterpret_cast<TransformAsset*>(scene.transforms[addedTransformIndex].ID));
}
}
void LinkAssets(SceneAsset& sceneAsset)
{
std::unordered_map<int64_t, AssetBase*> assetsMap;
for (auto& gameObject : sceneAsset.gameObjects) assetsMap.emplace(gameObject.ID, &gameObject);
for (auto& transform : sceneAsset.transforms) assetsMap.emplace(transform.ID, &transform);
for (auto& meshFilter : sceneAsset.meshFilters) assetsMap.emplace(meshFilter.ID, &meshFilter);
for (auto& gameObject : sceneAsset.gameObjects) LinkGameObject(assetsMap, gameObject);
for (auto& transform : sceneAsset.transforms) LinkTransform(assetsMap, transform);
for (auto& meshFilter : sceneAsset.meshFilters) LinkMeshFilter(assetsMap, meshFilter);
}
void ParseScene(SceneAsset& asset, const std::unordered_map<int64_t, ryml::Tree>& documents)
{
for (auto& [ID, tree] : documents)
{
try
{
ryml::ConstNodeRef root = tree.crootref();
// Each document should have one root node
if (root.num_children() > 0)
{
auto node = root.child(0).child(0); // The document root
auto assetType = node.key();
switch (fnv1a_hash(assetType))
{
case fnv1a_hash("GameObject"): asset.gameObjects.emplace_back(ParseGameObject(node)).ID = ID; break;
case fnv1a_hash("Transform"): asset.transforms.emplace_back(ParseTransform(node)).ID = ID; break;
case fnv1a_hash("MeshFilter"): asset.meshFilters.emplace_back(ParseMeshFilter(node)).ID = ID; break;
case fnv1a_hash("PrefabInstance"):
{
InstantiatePrefab(asset, tree);
break;
}
case fnv1a_hash("MonoBehaviour"):
{
auto scriptGuid = ParseAssetGUID(node["m_Script"]);
auto it = g_parsedProject.m_scriptToClassHash.find(scriptGuid);
if (it != g_parsedProject.m_scriptToClassHash.end())
{
switch (it->second)
{
case fnv1a_hash("Interactable_Resource"):
default:
break;
}
}
}
default:
std::cerr << assetType << '\n';
}
asset.IDtoAsset.emplace(ID, nullptr);
}
}
catch (const std::exception& e)
{
std::cerr << e.what();
}
}
LinkAssets(asset);
}
SceneAsset ParseSceneAsset(const AssetPath& path)
{
SceneAsset sceneAsset;
sceneAsset.path = path.path;
sceneAsset.name = path.path.stem().string();
// read the file
std::ifstream file(path.path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
auto objects = ParseYamlFile(content, true);
ParseScene(sceneAsset, objects);
return sceneAsset;
}
std::vector<SceneAsset> ParseScenes(const std::vector<AssetPath>& sceneFiles)
{
std::vector<SceneAsset> sceneAssets;
for (const auto& sceneFile : sceneFiles)
{
sceneAssets.emplace_back(ParseSceneAsset(sceneFile));
std::cout << "Parsed: " << sceneFile.path.filename() << '\n';
}
return sceneAssets;
}
PrefabAsset ParsePrefabAsset(const AssetPath& path)
{
PrefabAsset prefabAsset;
prefabAsset.path = path.path;
prefabAsset.name = path.path.stem().string();
{
// read the file
std::ifstream file(path.path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
prefabAsset.Data = ParseYamlFile(content, false);
}
return prefabAsset;
}
std::vector<PrefabAsset> ParsePrefabs(const std::vector<AssetPath>& prefabFiles, std::unordered_map<AssetGUID, PrefabAsset*>& prefabMap)
{
std::vector<PrefabAsset> prefabAssets;
for (const auto& prefabFile : prefabFiles)
{
prefabAssets.emplace_back(ParsePrefabAsset(prefabFile));
}
prefabMap.reserve(prefabAssets.size());
for (size_t i = 0; i < prefabAssets.size(); ++i)
{
prefabMap.emplace(prefabFiles[i].GUID, &prefabAssets[i]);
}
return prefabAssets;
}
void ParseDirectory(ParsedProject& project)
{
for (const auto& entry : std::filesystem::recursive_directory_iterator(project.m_projectRoot))
{
std::string extension = entry.path().extension().string();
if (!entry.is_directory())
{
if (extension == ".unity")
{
project.m_sceneFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".prefab")
{
project.m_prefabFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".cs")
{
auto guid = GetAssetGUIDFromFile(entry.path().string() + ".meta");
project.m_scriptFiles.push_back(AssetPath{ entry.path(), guid });
project.m_scriptToClassHash.emplace(guid, fnv1a_hash(entry.path().filename().string()));
}
continue;
if (extension == ".png" || extension == ".jpg" || extension == ".jpeg" || extension == ".bmp" || extension == ".tiff" || extension == ".webp")
{
project.m_imageFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".fbx" || extension == ".obj" || extension == ".glb" || extension == ".gltf")
{
project.m_meshFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
}
}
}
ParsedProject g_parsedProject;
void ParseProject(const std::filesystem::path& projectRoot)
{
g_parsedProject = ParsedProject{};
ParsedProject& project = g_parsedProject;
project.m_projectRoot = projectRoot;
ParseDirectory(project);
auto tilesFilesFilter = std::views::filter([](const AssetPath& path)
{
#ifdef _DEBUG
static auto pattern = std::regex(R"(Tiles\/10_3)");
#else
static auto pattern = std::regex(R"(Tiles\/\d+_\d+)");
#endif
return std::regex_search(path.path.generic_string(), pattern);
});
auto tilesFiles = project.m_sceneFiles | tilesFilesFilter;
auto prefabFilter = std::views::filter([](const AssetPath& path)
{
constexpr std::string_view prefabPath = "_GameAssets/Prefabs";
return path.path.generic_string().find(prefabPath) != std::string::npos;
});
auto prefabFiles = project.m_prefabFiles | prefabFilter;
project.m_prefabAssets = ParsePrefabs(std::vector<AssetPath>(prefabFiles.begin(), prefabFiles.end()), project.m_prefabsMap);
project.m_sceneAssets = ParseScenes(std::vector<AssetPath>(tilesFiles.begin(), tilesFiles.end()));
}} // namespace cursebreaker
#include "project_parser.h"
#include <string>
#include <iostream>
#include <vector>
#include <filesystem>
#include <fstream>
#include <unordered_map>
#include <string_view>
#include <span>
#include <thread>
#include <future>
#include <mutex>
#include <atomic>
#include <chrono>
#include <regex>
#include <ranges>
#include <algorithm>
#include <random>
#include <ryml.hpp>
#include <ryml_std.hpp>
#include <c4/format.hpp>
#include "assets/scene.h"
using namespace cursebreaker;
//constexpr uint32_t fnv1a_hash(const char* str, uint32_t hash = 2166136261u)
//{
// return (*str == '\0') ? hash : fnv1a_hash(str + 1, (hash ^ static_cast<uint32_t>(*str)) * 16777619u);
//}
//
//uint32_t fnv1a_hash(c4::csubstr substr)
//{
// uint32_t hash = 2166136261u;
// for (const auto& c : substr)
// {
// hash = (hash ^ static_cast<uint32_t>(c)) * 16777619u;
// }
// return hash;
//}
//
//uint32_t fnv1a_hash(std::string_view substr)
//{
// uint32_t hash = 2166136261u;
// for (const auto& c : substr)
// {
// hash = (hash ^ static_cast<uint32_t>(c)) * 16777619u;
// }
// return hash;
//}
AssetGUID GetAssetGUIDFromFile(const std::filesystem::path& path)
{
// regex match the GUID from the contents of the file
static auto pattern = std::regex(R"(guid: (\w+))");
std::smatch match{};
std::ifstream file(path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
if (std::regex_search(content, match, pattern))
{
assert(match[1].length() == 32);
AssetGUID guid{ std::string_view{ &*match[1].first, static_cast<size_t>(match[1].length()) } };
return guid;
}
return AssetGUID{};
}
void ParseSceneYaml(std::string& content,
bool in_place,
std::span<std::string_view> assetNames,
std::function<void(std::string_view, int64_t, ryml::Tree&&)> callback
)
{
// std::unordered_map<int64_t, ryml::Tree> Data{};
std::string::size_type start = content.find("---", 0);
std::string::size_type end = content.find("---", start + 1);
while (end != std::string::npos)
{
auto document = std::string_view(content.data() + start, content.data() + end);
// if the document contains "stripped", skip it
auto str_view = std::string_view(document.data(), document.size());
auto secondLine = str_view.find('\n') + 1;
auto classStr = std::string_view(document.data() + secondLine, str_view.find(':', secondLine) - secondLine);
if (str_view.find("stripped") != std::string_view::npos)
goto skip;
if (!assetNames.empty() && std::ranges::find(assetNames, classStr) == assetNames.end())
goto skip;
try
{
ryml::Tree tree{};
if (in_place)
{
tree = ryml::parse_in_place(c4::substr{ const_cast<char*>(document.data()), document.size() });
}
else
{
tree = ryml::parse_in_arena(c4::csubstr{ const_cast<char*>(document.data()), document.size() });
}
auto anchorData = tree.crootref().child(0).val_anchor();
int64_t ID{ };
auto [ptr, ec] = std::from_chars(anchorData.data(), anchorData.data() + anchorData.size(), ID);
assert(ec == std::errc{});
callback(classStr, ID, std::move(tree));
// Data.emplace(ID, std::move(tree));
}
catch (const std::runtime_error& e)
{
std::cerr << "Error parsing scene asset: " << e.what() << std::endl;
std::cerr << std::string_view(document.data(), document.size()) << std::endl;
}
skip:;
start = end;
end = content.find("---", start + 1);
}
// return Data;
}
/*
// OLD CODE - Commented out, replaced by new templated design
int64_t GetNewID(const Scene& scene, int64_t lastID = 0)
{
for (;; ++lastID)
{
if (scene.IDtoAsset.find(lastID) == scene.IDtoAsset.end())
return lastID;
}
}
template <typename T>
void MergeComponents(Scene& scene, std::unordered_map<int64_t, int64_t>& idMap, std::vector<T>& to, const std::vector<T>& from, int64_t& lastID)
{
for (const auto& asset : from)
{
// create a copy of the asset
auto assetCopy = asset;
// get a new ID
lastID = GetNewID(scene, lastID);
assetCopy.ID = lastID;
// register the new ID to the scene
scene.IDtoAsset.emplace(assetCopy.ID, nullptr);
// add the asset to the scene
to.emplace_back(assetCopy);
}
}
void MergeScenes(Scene& to, const Scene& from)
{
std::unordered_map<int64_t, int64_t> newIDMap{};
// randomize the IDs to avoid conflicts
int64_t lastID = std::random_device{}();
MergeComponents(to, newIDMap, to.gameObjects, from.gameObjects, lastID);
MergeComponents(to, newIDMap, to.transforms, from.transforms, lastID);
MergeComponents(to, newIDMap, to.meshFilters, from.meshFilters, lastID);
auto& IDMapLinked = reinterpret_cast<std::unordered_map<int64_t, TypeBase*>&>(newIDMap);
for (auto& gameObject : to.gameObjects) LinkGameObject(IDMapLinked, gameObject);
for (auto& transform : to.transforms) LinkTransform(IDMapLinked, transform);
for (auto& meshFilter : to.meshFilters) LinkMeshFilter(IDMapLinked, meshFilter);
}
void ParseScene(Scene& asset, const std::unordered_map<int64_t, ryml::Tree>& documents);
*/
/*
auto split_by_dot(std::string_view str) {
return str
| std::views::split('.')
| std::views::transform([](auto&& rng) {
return std::string_view(&*rng.begin(), std::ranges::distance(rng));
});
}
void InstantiatePrefab(Scene& parentScene, const ryml::Tree& instance)
{
auto instanceData = instance.crootref().child(0).child(0);
// parse the prebad UID
AssetGUID prefabAssetGUID = ParseAssetGUID(instanceData["m_SourcePrefab"]);
auto prefabAssetIt = g_parsedProject.m_prefabsMap.find(prefabAssetGUID);
if (prefabAssetIt == g_parsedProject.m_prefabsMap.end())
{
std::cerr << "Prefab asset not found: " << std::endl;
return;
}
const PrefabAsset& prefabAsset = *prefabAssetIt->second;
auto prefabAssetTree = prefabAsset.Data;
// apply the modifications to the prefab asset tree
const auto& overrides = instanceData["m_Modification"]["m_Modifications"];
for (auto override : overrides)
{
int64_t ref = reinterpret_cast<int64_t>(ParseObjectRef<void>(override["target"]));
auto prefabAssetTreeIt = prefabAssetTree.find(ref);
if (prefabAssetTreeIt == prefabAssetTree.end())
{
std::cerr << "Prefab asset tree not found: " << ref << std::endl;
continue;
}
auto& targetTree = prefabAssetTreeIt->second;
const auto propertyPath{ override["propertyPath"].val() };
const auto& overrideValue = override["value"];
try
{
ryml::NodeRef node{ targetTree.rootref().child(0).child(0) };
for (std::string_view property : split_by_dot(std::string_view{ propertyPath.data(), propertyPath.size() }))
{
node = node[c4::substr{ const_cast<char*>(property.data()), property.size() }];
}
node << overrideValue.val();
}
catch (std::exception e){}
}
// parse the prefab asset tree into a scene
Scene scene{};
ParseScene(scene, prefabAssetTree);
// get the index of the added transform
size_t addedTransformIndex = scene.transforms.size();
// merge the scenes
MergeScenes(parentScene, scene);
// find the parent transform and add a the instantiated prebab to the children
auto parentID = ParseObjectRef<Transform>(instanceData["m_TransformParent"]);
scene.transforms[addedTransformIndex].Parent = parentID;
auto parentTransform = std::find_if(scene.transforms.begin(), scene.transforms.end(), [parentID](const Transform& asset)
{
return asset.ID == reinterpret_cast<int64_t>(parentID);
});
if (parentTransform != scene.transforms.end())
{
parentTransform->Children.push_back(reinterpret_cast<Transform*>(scene.transforms[addedTransformIndex].ID));
}
}
*/
/*
// OLD CODE - Commented out, replaced by new templated design in project_parser.hpp
void LinkAssets(Scene& Scene)
{
std::unordered_map<int64_t, TypeBase*> assetsMap;
for (auto& gameObject : Scene.gameObjects) assetsMap.emplace(gameObject.ID, &gameObject);
for (auto& transform : Scene.transforms) assetsMap.emplace(transform.ID, &transform);
for (auto& meshFilter : Scene.meshFilters) assetsMap.emplace(meshFilter.ID, &meshFilter);
for (auto& gameObject : Scene.gameObjects) LinkGameObject(assetsMap, gameObject);
for (auto& transform : Scene.transforms) LinkTransform(assetsMap, transform);
for (auto& meshFilter : Scene.meshFilters) LinkMeshFilter(assetsMap, meshFilter);
}
void ParseScene(Scene& asset, const std::unordered_map<int64_t, ryml::Tree>& documents)
{
for (auto& [ID, tree] : documents)
{
try
{
ryml::ConstNodeRef root = tree.crootref();
// Each document should have one root node
if (root.num_children() > 0)
{
auto node = root.child(0).child(0); // The document root
auto assetType = node.key();
switch (fnv1a_hash(assetType))
{
case fnv1a_hash("GameObject"): asset.gameObjects.emplace_back(ParseGameObject(node)).ID = ID; break;
case fnv1a_hash("Transform"): asset.transforms.emplace_back(ParseTransform(node)).ID = ID; break;
case fnv1a_hash("MeshFilter"): asset.meshFilters.emplace_back(ParseMeshFilter(node)).ID = ID; break;
case fnv1a_hash("PrefabInstance"):
{
InstantiatePrefab(asset, tree);
break;
}
case fnv1a_hash("MonoBehaviour"):
{
auto scriptGuid = ParseAssetGUID(node["m_Script"]);
auto it = g_parsedProject.m_scriptToClassHash.find(scriptGuid);
if (it != g_parsedProject.m_scriptToClassHash.end())
{
switch (it->second)
{
case fnv1a_hash("Interactable_Resource"):
asset.gameObjects.emplace_back(ParseInteractableResource(node)).ID = ID; break;
default:
break;
}
}
}
default:
std::cerr << assetType << '\n';
}
asset.IDtoAsset.emplace(ID, nullptr);
}
}
catch (const std::exception& e)
{
std::cerr << e.what();
}
}
LinkAssets(asset);
}
Scene ParseScene(const AssetPath& path)
{
Scene Scene;
Scene.path = path.path;
Scene.name = path.path.stem().string();
// read the file
std::ifstream file(path.path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
std::unordered_map<int64_t, ryml::Tree> objects;
ParseSceneYaml(content, true, {}, [&objects](std::string_view classStr, int64_t ID, ryml::Tree&& tree) {
objects.emplace(ID, std::move(tree));
});
ParseScene(Scene, objects);
return Scene;
}
std::vector<Scene> ParseScenes(const std::vector<AssetPath>& sceneFiles)
{
std::vector<Scene> Scenes;
for (const auto& sceneFile : sceneFiles)
{
Scenes.emplace_back(ParseScene(sceneFile));
std::cout << "Parsed: " << sceneFile.path.filename() << '\n';
}
return Scenes;
}
PrefabAsset ParsePrefabAsset(const AssetPath& path)
{
PrefabAsset prefabAsset;
prefabAsset.path = path.path;
prefabAsset.name = path.path.stem().string();
{
// read the file
std::ifstream file(path.path);
std::string content{ std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
ParseSceneYaml(content, false, {}, [&prefabAsset](std::string_view classStr, int64_t ID, ryml::Tree&& tree) {
prefabAsset.Data.emplace(ID, std::move(tree));
});
}
return prefabAsset;
}
std::vector<PrefabAsset> ParsePrefabs(const std::vector<AssetPath>& prefabFiles, std::unordered_map<AssetGUID, PrefabAsset*>& prefabMap)
{
std::vector<PrefabAsset> prefabAssets;
for (const auto& prefabFile : prefabFiles)
{
prefabAssets.emplace_back(ParsePrefabAsset(prefabFile));
}
prefabMap.reserve(prefabAssets.size());
for (size_t i = 0; i < prefabAssets.size(); ++i)
{
prefabMap.emplace(prefabFiles[i].GUID, &prefabAssets[i]);
}
return prefabAssets;
}
*/
/*
void ParseDirectory(ParsedProjectBase& project)
{
for (const auto& entry : std::filesystem::recursive_directory_iterator(project.m_projectRoot))
{
std::string extension = entry.path().extension().string();
if (!entry.is_directory())
{
if (extension == ".unity")
{
project.m_sceneFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".prefab")
{
project.m_prefabFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".cs")
{
auto guid = GetAssetGUIDFromFile(entry.path().string() + ".meta");
project.m_scriptFiles.push_back(AssetPath{ entry.path(), guid });
project.m_scriptToClassName.emplace(guid, entry.path().filename().string());
}
continue;
if (extension == ".png" || extension == ".jpg" || extension == ".jpeg" || extension == ".bmp" || extension == ".tiff" || extension == ".webp")
{
project.m_imageFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
else if (extension == ".fbx" || extension == ".obj" || extension == ".glb" || extension == ".gltf")
{
project.m_meshFiles.push_back(AssetPath{ entry.path(), GetAssetGUIDFromFile(entry.path().string() + ".meta") });
}
}
}
}
ParsedProject g_parsedProject;
*/
/*
// OLD CODE - Commented out, replaced by new templated design in project_parser.hpp
void ParseProject(const std::filesystem::path& projectRoot, ParsedProjectBase& project)
{
auto tilesFilesFilter = std::views::filter([](const AssetPath& path)
{
#ifdef _DEBUG
static auto pattern = std::regex(R"(Tiles\/10_3)");
#else
static auto pattern = std::regex(R"(Tiles\/\d+_\d+)");
#endif
return std::regex_search(path.path.generic_string(), pattern);
});
auto tilesFiles = project.m_sceneFiles | tilesFilesFilter;
auto prefabFilter = std::views::filter([](const AssetPath& path)
{
constexpr std::string_view prefabPath = "_GameAssets/Prefabs";
return path.path.generic_string().find(prefabPath) != std::string::npos;
});
auto prefabFiles = project.m_prefabFiles | prefabFilter;
project.m_prefabAssets = ParsePrefabs(std::vector<AssetPath>(prefabFiles.begin(), prefabFiles.end()), project.m_prefabsMap);
project.m_Scenes = ParseScenes(std::vector<AssetPath>(tilesFiles.begin(), tilesFiles.end()));
}
*/

89
src/tree_builder.cpp
View File

@@ -1,54 +1,35 @@
#include "tree_builder.h"
#include "assets/scene.hpp"
#include "assets/transform.hpp"
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
glm::mat4 composeMatrix(const glm::vec3& pos, const glm::vec3& scale, const glm::quat& rotation) {
// Create translation matrix
glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), pos);
// Convert quaternion to rotation matrix
glm::mat4 rotationMatrix = glm::mat4_cast(rotation);
// Create scale matrix
glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), scale);
// Combine: translation * rotation * scale
return translationMatrix * rotationMatrix * scaleMatrix;
}
void BuildTreeHelper(TransformAsset& transform, const glm::mat4& parentMatrix)
{
for (auto& child : transform.Children)
{
auto childMatrix = composeMatrix(transform.Position, transform.Scale, transform.Rotation);
transform.GlobalMatrix = parentMatrix * childMatrix;
BuildTreeHelper(*child, transform.GlobalMatrix);
}
}
void BuildTree(SceneAsset& sceneAsset)
{
// find transforms with no parent
std::vector<TransformAsset*> rootTransforms;
for (auto& transform : sceneAsset.transforms)
{
if (transform.Parent == nullptr)
{
rootTransforms.push_back(&transform);
}
}
// build tree
for (auto rootTransform : rootTransforms)
{
BuildTreeHelper(*rootTransform, glm::mat4(1.0f));
}
}
#include "tree_builder.h"
#include "assets/scene.h"
#include "types/transform.h"
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
glm::mat4 composeMatrix(const glm::vec3& pos, const glm::vec3& scale, const glm::quat& rotation) {
// Create translation matrix
glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), pos);
// Convert quaternion to rotation matrix
glm::mat4 rotationMatrix = glm::mat4_cast(rotation);
// Create scale matrix
glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), scale);
// Combine: translation * rotation * scale
return translationMatrix * rotationMatrix * scaleMatrix;
}
void BuildTreeHelper(Transform& transform, const glm::mat4& parentMatrix)
{
for (auto& child : transform.Children)
{
auto childMatrix = composeMatrix(transform.Position, transform.Scale, transform.Rotation);
transform.GlobalMatrix = parentMatrix * childMatrix;
BuildTreeHelper(*child, transform.GlobalMatrix);
}
}

45
src/types/game_object.cpp Normal file
View File

@@ -0,0 +1,45 @@
#include "types/game_object.h"
#include "project_parser.h"
#include "configs/helpers.h"
void GameObject::Parse(const ryml::ConstNodeRef& node, ParseContext& context)
{
node["m_Name"] >> name;
node["m_Layer"] >> layer;
node["m_TagString"] >> tag;
auto components = node["m_Component"];
auto it = components.begin();
transform = ParseObjectRef<Transform>((*it)["component"]);
for (; it != components.end(); ++it)
{
Components.push_back(ParseObjectRef<TypeBase>((*it)["component"]));
}
}
void GameObject::Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap)
{
LinkObjectRef<Transform>(assetsMap, transform);
// Clear the component mask before rebuilding it
ComponentMask.reset();
for (int i = static_cast<int>(Components.size()) - 1; i >= 0; i--)
{
if (!LinkObjectRef<TypeBase>(assetsMap, Components[i]))
{
std::swap(Components[i], Components.back());
Components.pop_back();
}
else
{
// Set the bit for this component's type
if (Components[i]->TypeID >= 0 && Components[i]->TypeID < 64)
{
ComponentMask.set(Components[i]->TypeID);
}
}
}
}

6
src/types/interactable_resource.cpp Normal file
View File

@@ -0,0 +1,6 @@
#include "types/interactable_resource.h"
void Interactable_Resource::Parse(const ryml::ConstNodeRef& node, ParseContext& context)
{
node["typeId"] >> ResourceID;
}

14
src/types/mesh_filter.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "types/mesh_filter.h"
#include "types/game_object.h"
#include "project_parser.h"
void MeshFilter::Parse(const ryml::ConstNodeRef& node, ParseContext& context)
{
Mesh = ParseAssetGUID(node["m_Mesh"]);
GameObject = ParseObjectRef<::GameObject>(node["m_GameObject"]);
}
void MeshFilter::Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap)
{
LinkObjectRef<::GameObject>(assetsMap, GameObject);
}

77
src/types/prefab_instance.cpp Normal file
View File

@@ -0,0 +1,77 @@
#include "types/prefab_instance.h"
#include <iostream>
#include <ranges>
#include "assets/prefab.h"
auto split_by_dot(std::string_view str) {
return str
| std::views::split('.')
| std::views::transform([](auto&& rng) {
return std::string_view(&*rng.begin(), std::ranges::distance(rng));
});
}
void PrefabInstance::Parse(const ryml::ConstNodeRef& node, ParseContext& context)
{
// parse the prefab UID
AssetGUID prefabAssetGUID = ParseAssetGUID(node["m_SourcePrefab"]);
auto prefabAssetIt = context.Assets.GetAsset<Prefab>(prefabAssetGUID);
if (prefabAssetIt == nullptr)
{
std::cerr << "Prefab asset not found: " << std::endl;
return;
}
auto prefabAssetTree = prefabAssetIt->Data;
// apply the modifications to the prefab asset tree
const auto& overrides = node["m_Modification"]["m_Modifications"];
for (auto override : overrides)
{
int64_t ref = reinterpret_cast<int64_t>(ParseObjectRef<void>(override["target"]));
auto prefabAssetTreeIt = prefabAssetTree.find(ref);
if (prefabAssetTreeIt == prefabAssetTree.end())
{
std::cerr << "Prefab asset tree not found: " << ref << std::endl;
continue;
}
auto& targetTree = prefabAssetTreeIt->second;
const auto propertyPath{ override["propertyPath"].val() };
const auto& overrideValue = override["value"];
try
{
ryml::NodeRef node{ targetTree.rootref().child(0).child(0) };
for (std::string_view property : split_by_dot(std::string_view{ propertyPath.data(), propertyPath.size() }))
{
node = node[c4::substr{ const_cast<char*>(property.data()), property.size() }];
}
node << overrideValue.val();
}
catch (std::exception e){}
}
// parse the prefab asset tree into a scene
Scene scene{}
ParseScene(scene, prefabAssetTree);
// get the index of the added transform
size_t addedTransformIndex = scene.transforms.size();
// merge the scenes
MergeScenes(context.MainScene, scene);
// find the parent transform and add the instantiated prefab to the children
auto parentID = ParseObjectRef<Transform>(node["m_TransformParent"]);
scene.transforms[addedTransformIndex].Parent = parentID;
auto parentTransform = std::find_if(scene.transforms.begin(), scene.transforms.end(), [parentID](const Transform& asset)
{
return asset.ID == reinterpret_cast<int64_t>(parentID);
});
if (parentTransform != scene.transforms.end())
{
parentTransform->Children.push_back(reinterpret_cast<Transform*>(scene.transforms[addedTransformIndex].ID));
}
}

51
src/types/transform.cpp Normal file
View File

@@ -0,0 +1,51 @@
#include "types/transform.h"
#include "types/game_object.h"
inline glm::vec3 ParseVector3(const ryml::ConstNodeRef& node)
{
glm::vec3 vector;
node["x"] >> vector.x;
node["y"] >> vector.y;
node["z"] >> vector.z;
return vector;
}
inline glm::quat ParseQuaternion(const ryml::ConstNodeRef& node)
{
glm::quat quaternion;
node["x"] >> quaternion.x;
node["y"] >> quaternion.y;
node["z"] >> quaternion.z;
node["w"] >> quaternion.w;
return quaternion;
}
void Transform::Parse(const ryml::ConstNodeRef& node, ParseContext& context)
{
Rotation = ParseQuaternion(node["m_LocalRotation"]);
Position = ParseVector3(node["m_LocalPosition"]);
Scale = ParseVector3(node["m_LocalScale"]);
Parent = ParseObjectRef<::Transform>(node["m_Father"]);
GameObject = ParseObjectRef<::GameObject>(node["m_GameObject"]);
auto children = node["m_Children"];
for (const auto& child : children)
{
Children.push_back(ParseObjectRef<::Transform>(child));
}
}
void Transform::Link(const std::unordered_map<int64_t, TypeBase*>& assetsMap)
{
LinkObjectRef<::Transform>(assetsMap, Parent);
for (int i = static_cast<int>(Children.size()) - 1; i >= 0; i--)
{
if (!LinkObjectRef<::Transform>(assetsMap, Children[i]))
{
std::swap(Children[i], Children.back());
Children.pop_back();
}
}
LinkObjectRef<::GameObject>(assetsMap, GameObject);
}