prefab_transform_overrides_component.h

#pragma once
 
#include "pixelbullet/scene/entity_id.h"
#include "pixelbullet/scene/components/transform.h"
#include "pixelbullet/serialization/node.h"
 
#include <algorithm>
#include <vector>
 
namespace pixelbullet
{
namespace prefab_transform_overrides_component_internal
{
[[nodiscard]] inline bool TransformValuesEqual(const Transform& lhs, const Transform& rhs) noexcept
{
    return lhs.position == rhs.position && lhs.rotation == rhs.rotation && lhs.scale == rhs.scale;
}
} // namespace prefab_transform_overrides_component_internal
 
struct PrefabTransformOverrideEntry
{
    EntityId prefab_entity = EntityId::Invalid();
    Transform transform{};
 
    [[nodiscard]] bool operator==(const PrefabTransformOverrideEntry& other) const noexcept
    {
        return prefab_entity == other.prefab_entity &&
               prefab_transform_overrides_component_internal::TransformValuesEqual(transform, other.transform);
    }
};
 
inline void NormalizePrefabTransformOverrideEntries(std::vector<PrefabTransformOverrideEntry>& overrides)
{
    std::vector<PrefabTransformOverrideEntry> normalized;
    normalized.reserve(overrides.size());
    for (PrefabTransformOverrideEntry& override_entry : overrides)
    {
        if (!override_entry.prefab_entity)
        {
            continue;
        }
 
        std::erase_if(normalized, [&](const PrefabTransformOverrideEntry& existing)
                      { return existing.prefab_entity == override_entry.prefab_entity; });
        normalized.push_back(std::move(override_entry));
    }
 
    overrides = std::move(normalized);
}
 
inline Node& operator<<(Node& node, const PrefabTransformOverrideEntry& entry)
{
    node["entity"] << entry.prefab_entity;
    node["transform"] << entry.transform;
    return node;
}
 
inline const Node& operator>>(const Node& node, PrefabTransformOverrideEntry& entry)
{
    if (node.HasProperty("entity"))
    {
        node["entity"] >> entry.prefab_entity;
    }
    else
    {
        entry.prefab_entity = EntityId::Invalid();
    }
 
    if (node.HasProperty("transform"))
    {
        node["transform"] >> entry.transform;
    }
    else
    {
        entry.transform = Transform{};
    }
 
    return node;
}
 
struct PrefabTransformOverridesComponent
{
    std::vector<PrefabTransformOverrideEntry> transform_overrides;
 
    [[nodiscard]] const PrefabTransformOverrideEntry* FindTransformOverride(const EntityId prefab_entity) const noexcept
    {
        const auto it =
            std::find_if(transform_overrides.begin(), transform_overrides.end(),
                         [&](const PrefabTransformOverrideEntry& entry) { return entry.prefab_entity == prefab_entity; });
        return it == transform_overrides.end() ? nullptr : &(*it);
    }
 
    [[nodiscard]] bool operator==(const PrefabTransformOverridesComponent& other) const noexcept
    {
        return transform_overrides == other.transform_overrides;
    }
};
 
inline Node& operator<<(Node& node, const PrefabTransformOverridesComponent& component)
{
    if (!component.transform_overrides.empty())
    {
        node["transformOverrides"] << component.transform_overrides;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, PrefabTransformOverridesComponent& component)
{
    if (node.HasProperty("transformOverrides"))
    {
        node["transformOverrides"] >> component.transform_overrides;
    }
    else
    {
        component.transform_overrides.clear();
    }
 
    NormalizePrefabTransformOverrideEntries(component.transform_overrides);
    return node;
}
} // namespace pixelbullet