transform_animation_component.h

#pragma once
 
#include "pixelbullet/scene/components/animation_state_component.h"
#include "pixelbullet/scene/components/transform.h"
 
#include <algorithm>
#include <cmath>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
struct TransformKeyframe
{
    float time_seconds = 0.0f;
    Transform transform{};
};
 
inline bool operator==(const TransformKeyframe& lhs, const TransformKeyframe& rhs)
{
    return lhs.time_seconds == rhs.time_seconds && lhs.transform.position == rhs.transform.position &&
           lhs.transform.rotation == rhs.transform.rotation && lhs.transform.scale == rhs.transform.scale;
}
 
inline bool operator!=(const TransformKeyframe& lhs, const TransformKeyframe& rhs)
{
    return !(lhs == rhs);
}
 
inline void NormalizeTransformAnimationKeys(std::vector<TransformKeyframe>& keys)
{
    for (auto& key : keys)
    {
        key.time_seconds = std::max(key.time_seconds, 0.0f);
    }
 
    std::stable_sort(keys.begin(), keys.end(),
                     [](const TransformKeyframe& lhs, const TransformKeyframe& rhs) { return lhs.time_seconds < rhs.time_seconds; });
 
    std::vector<TransformKeyframe> normalized;
    normalized.reserve(keys.size());
    for (const TransformKeyframe& key : keys)
    {
        if (!normalized.empty() && std::abs(normalized.back().time_seconds - key.time_seconds) <= 0.0001f)
        {
            normalized.back() = key;
        }
        else
        {
            normalized.push_back(key);
        }
    }
 
    keys = std::move(normalized);
}
 
inline float ResolveTransformAnimationClipLength(const std::vector<TransformKeyframe>& keys) noexcept
{
    return keys.empty() ? 0.0f : std::max(keys.back().time_seconds, 0.0f);
}
 
struct TransformAnimationClip
{
    std::string name = "Default";
    std::vector<TransformKeyframe> keys;
};
 
inline bool operator==(const TransformAnimationClip& lhs, const TransformAnimationClip& rhs)
{
    return lhs.name == rhs.name && lhs.keys == rhs.keys;
}
 
inline bool operator!=(const TransformAnimationClip& lhs, const TransformAnimationClip& rhs)
{
    return !(lhs == rhs);
}
 
inline void NormalizeTransformAnimationClip(TransformAnimationClip& clip)
{
    NormalizeTransformAnimationKeys(clip.keys);
}
 
inline float ResolveTransformAnimationClipLength(const TransformAnimationClip& clip) noexcept
{
    return ResolveTransformAnimationClipLength(clip.keys);
}
 
struct TransformAnimationComponent
{
    std::vector<TransformAnimationClip> clips;
};
 
inline bool operator==(const TransformAnimationComponent& lhs, const TransformAnimationComponent& rhs)
{
    return lhs.clips == rhs.clips;
}
 
inline bool operator!=(const TransformAnimationComponent& lhs, const TransformAnimationComponent& rhs)
{
    return !(lhs == rhs);
}
 
inline std::string NormalizeAnimationClipName(std::string_view name, std::string_view fallback)
{
    std::string normalized = name.empty() ? std::string(fallback) : std::string(name);
    if (normalized.empty())
    {
        normalized = std::string(fallback);
    }
    return normalized;
}
 
inline void NormalizeTransformAnimationComponent(TransformAnimationComponent& component)
{
    std::unordered_map<std::string, std::size_t> counts;
    for (TransformAnimationClip& clip : component.clips)
    {
        NormalizeTransformAnimationClip(clip);
        std::string normalized_name = NormalizeAnimationClipName(clip.name, "Default");
        const auto [it, inserted] = counts.emplace(normalized_name, 0u);
        if (!inserted)
        {
            ++it->second;
            normalized_name += " " + std::to_string(it->second + 1u);
        }
        clip.name = std::move(normalized_name);
    }
}
 
inline const TransformAnimationClip* FindTransformAnimationClip(const TransformAnimationComponent& component, const std::string_view name)
{
    for (const TransformAnimationClip& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline TransformAnimationClip* FindTransformAnimationClip(TransformAnimationComponent& component, const std::string_view name)
{
    for (TransformAnimationClip& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline const TransformAnimationClip* ResolveActiveTransformAnimationClip(const TransformAnimationComponent& component,
                                                                         const AnimationStateComponent* state = nullptr)
{
    if (component.clips.empty())
    {
        return nullptr;
    }
 
    if (state != nullptr && !state->active_clip.empty())
    {
        if (const TransformAnimationClip* clip = FindTransformAnimationClip(component, state->active_clip))
        {
            return clip;
        }
    }
 
    return &component.clips.front();
}
 
inline float ResolveTransformAnimationClipLength(const TransformAnimationComponent& component,
                                                 const AnimationStateComponent* state) noexcept
{
    if (const TransformAnimationClip* clip = ResolveActiveTransformAnimationClip(component, state))
    {
        return ResolveTransformAnimationClipLength(*clip);
    }
 
    return 0.0f;
}
 
inline float ResolveTransformAnimationClipLength(const TransformAnimationComponent& component) noexcept
{
    return ResolveTransformAnimationClipLength(component, nullptr);
}
 
inline Node& operator<<(Node& node, const TransformKeyframe& keyframe)
{
    node["timeSeconds"] << keyframe.time_seconds;
    node["position"] << keyframe.transform.position;
    node["rotation"] << keyframe.transform.rotation;
    node["scale"] << keyframe.transform.scale;
    return node;
}
 
inline const Node& operator>>(const Node& node, TransformKeyframe& keyframe)
{
    node["timeSeconds"] >> keyframe.time_seconds;
    node["position"] >> keyframe.transform.position;
    node["rotation"] >> keyframe.transform.rotation;
    node["scale"] >> keyframe.transform.scale;
    keyframe.time_seconds = std::max(keyframe.time_seconds, 0.0f);
    return node;
}
 
inline Node& operator<<(Node& node, const TransformAnimationClip& clip)
{
    node["name"] << clip.name;
    node["keys"] << clip.keys;
    return node;
}
 
inline const Node& operator>>(const Node& node, TransformAnimationClip& clip)
{
    if (node.HasProperty("name"))
    {
        node["name"] >> clip.name;
    }
    else
    {
        clip.name = "Default";
    }
 
    if (node.HasProperty("keys"))
    {
        node["keys"] >> clip.keys;
    }
    else
    {
        clip.keys.clear();
    }
 
    NormalizeTransformAnimationClip(clip);
    return node;
}
 
inline Node& operator<<(Node& node, const TransformAnimationComponent& component)
{
    node["clips"] << component.clips;
    return node;
}
 
inline const Node& operator>>(const Node& node, TransformAnimationComponent& component)
{
    component.clips.clear();
    if (node.HasProperty("clips"))
    {
        node["clips"] >> component.clips;
    }
    else
    {
        TransformAnimationClip clip;
        clip.name = "Default";
        if (node.HasProperty("keys"))
        {
            node["keys"] >> clip.keys;
        }
        NormalizeTransformAnimationClip(clip);
        if (!clip.keys.empty() || node.HasProperty("enabled"))
        {
            component.clips.push_back(std::move(clip));
        }
    }
 
    NormalizeTransformAnimationComponent(component);
    return node;
}
} // namespace pixelbullet