morph_weights_animation_component.h

#pragma once
 
#include "pixelbullet/scene/components/animation_state_component.h"
#include "pixelbullet/serialization/node.h"
 
#include <algorithm>
#include <cmath>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
struct MorphWeightsKeyframe
{
    float time_seconds = 0.0f;
    std::vector<float> weights;
};
 
inline bool operator==(const MorphWeightsKeyframe& lhs, const MorphWeightsKeyframe& rhs)
{
    return lhs.time_seconds == rhs.time_seconds && lhs.weights == rhs.weights;
}
 
inline bool operator!=(const MorphWeightsKeyframe& lhs, const MorphWeightsKeyframe& rhs)
{
    return !(lhs == rhs);
}
 
inline void NormalizeMorphWeightsAnimationKeys(std::vector<MorphWeightsKeyframe>& keys)
{
    for (auto& key : keys)
    {
        key.time_seconds = std::max(key.time_seconds, 0.0f);
    }
 
    std::stable_sort(keys.begin(), keys.end(),
                     [](const MorphWeightsKeyframe& lhs, const MorphWeightsKeyframe& rhs) { return lhs.time_seconds < rhs.time_seconds; });
 
    std::vector<MorphWeightsKeyframe> normalized;
    normalized.reserve(keys.size());
    for (const MorphWeightsKeyframe& 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 ResolveMorphWeightsAnimationClipLength(const std::vector<MorphWeightsKeyframe>& keys) noexcept
{
    return keys.empty() ? 0.0f : std::max(keys.back().time_seconds, 0.0f);
}
 
struct MorphWeightsAnimationClip
{
    std::string name = "Default";
    std::vector<MorphWeightsKeyframe> keys;
};
 
inline bool operator==(const MorphWeightsAnimationClip& lhs, const MorphWeightsAnimationClip& rhs)
{
    return lhs.name == rhs.name && lhs.keys == rhs.keys;
}
 
inline bool operator!=(const MorphWeightsAnimationClip& lhs, const MorphWeightsAnimationClip& rhs)
{
    return !(lhs == rhs);
}
 
inline std::string NormalizeMorphAnimationClipName(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 NormalizeMorphWeightsAnimationClip(MorphWeightsAnimationClip& clip)
{
    NormalizeMorphWeightsAnimationKeys(clip.keys);
}
 
inline float ResolveMorphWeightsAnimationClipLength(const MorphWeightsAnimationClip& clip) noexcept
{
    return ResolveMorphWeightsAnimationClipLength(clip.keys);
}
 
struct MorphWeightsAnimationComponent
{
    std::vector<MorphWeightsAnimationClip> clips;
};
 
inline bool operator==(const MorphWeightsAnimationComponent& lhs, const MorphWeightsAnimationComponent& rhs)
{
    return lhs.clips == rhs.clips;
}
 
inline bool operator!=(const MorphWeightsAnimationComponent& lhs, const MorphWeightsAnimationComponent& rhs)
{
    return !(lhs == rhs);
}
 
inline void NormalizeMorphWeightsAnimationComponent(MorphWeightsAnimationComponent& component)
{
    std::unordered_map<std::string, std::size_t> counts;
    for (MorphWeightsAnimationClip& clip : component.clips)
    {
        NormalizeMorphWeightsAnimationClip(clip);
        std::string normalized_name = NormalizeMorphAnimationClipName(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 MorphWeightsAnimationClip* FindMorphWeightsAnimationClip(const MorphWeightsAnimationComponent& component,
                                                                      const std::string_view name)
{
    for (const MorphWeightsAnimationClip& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline MorphWeightsAnimationClip* FindMorphWeightsAnimationClip(MorphWeightsAnimationComponent& component, const std::string_view name)
{
    for (MorphWeightsAnimationClip& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline const MorphWeightsAnimationClip* ResolveActiveMorphWeightsAnimationClip(const MorphWeightsAnimationComponent& component,
                                                                               const AnimationStateComponent* state = nullptr)
{
    if (component.clips.empty())
    {
        return nullptr;
    }
 
    if (state != nullptr && !state->active_clip.empty())
    {
        if (const MorphWeightsAnimationClip* clip = FindMorphWeightsAnimationClip(component, state->active_clip))
        {
            return clip;
        }
    }
 
    return &component.clips.front();
}
 
inline float ResolveMorphWeightsAnimationClipLength(const MorphWeightsAnimationComponent& component,
                                                    const AnimationStateComponent* state) noexcept
{
    if (const MorphWeightsAnimationClip* clip = ResolveActiveMorphWeightsAnimationClip(component, state))
    {
        return ResolveMorphWeightsAnimationClipLength(*clip);
    }
 
    return 0.0f;
}
 
inline float ResolveMorphWeightsAnimationClipLength(const MorphWeightsAnimationComponent& component) noexcept
{
    return ResolveMorphWeightsAnimationClipLength(component, nullptr);
}
 
inline Node& operator<<(Node& node, const MorphWeightsKeyframe& keyframe)
{
    node["timeSeconds"] << keyframe.time_seconds;
    node["weights"] << keyframe.weights;
    return node;
}
 
inline const Node& operator>>(const Node& node, MorphWeightsKeyframe& keyframe)
{
    node["timeSeconds"] >> keyframe.time_seconds;
    if (node.HasProperty("weights"))
    {
        node["weights"] >> keyframe.weights;
    }
    else
    {
        keyframe.weights.clear();
    }
    keyframe.time_seconds = std::max(keyframe.time_seconds, 0.0f);
    return node;
}
 
inline Node& operator<<(Node& node, const MorphWeightsAnimationClip& clip)
{
    node["name"] << clip.name;
    node["keys"] << clip.keys;
    return node;
}
 
inline const Node& operator>>(const Node& node, MorphWeightsAnimationClip& 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();
    }
 
    NormalizeMorphWeightsAnimationClip(clip);
    return node;
}
 
inline Node& operator<<(Node& node, const MorphWeightsAnimationComponent& component)
{
    node["clips"] << component.clips;
    return node;
}
 
inline const Node& operator>>(const Node& node, MorphWeightsAnimationComponent& component)
{
    component.clips.clear();
    if (node.HasProperty("clips"))
    {
        node["clips"] >> component.clips;
    }
    else
    {
        MorphWeightsAnimationClip clip;
        clip.name = "Default";
        if (node.HasProperty("keys"))
        {
            node["keys"] >> clip.keys;
        }
        NormalizeMorphWeightsAnimationClip(clip);
        if (!clip.keys.empty() || node.HasProperty("enabled"))
        {
            component.clips.push_back(std::move(clip));
        }
    }
 
    NormalizeMorphWeightsAnimationComponent(component);
    return node;
}
} // namespace pixelbullet