skeleton_animation_component.h

#pragma once
 
#include "pixelbullet/filesystem/virtual_path.h"
#include "pixelbullet/filesystem/virtual_path_serialization.h"
#include "pixelbullet/scene/components/animation_state_component.h"
#include "pixelbullet/scene/entity_id.h"
#include "pixelbullet/serialization/node.h"
 
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
struct SkeletonAnimationClipBinding
{
    std::string name = "Default";
    VirtualPath clip_asset;
};
 
inline bool operator==(const SkeletonAnimationClipBinding& lhs, const SkeletonAnimationClipBinding& rhs)
{
    return lhs.name == rhs.name && lhs.clip_asset == rhs.clip_asset;
}
 
inline bool operator!=(const SkeletonAnimationClipBinding& lhs, const SkeletonAnimationClipBinding& rhs)
{
    return !(lhs == rhs);
}
 
struct SkeletonAnimationComponent
{
    VirtualPath skeleton_asset;
    std::vector<EntityId> joint_entities;
    std::vector<SkeletonAnimationClipBinding> clips;
};
 
inline bool operator==(const SkeletonAnimationComponent& lhs, const SkeletonAnimationComponent& rhs)
{
    return lhs.skeleton_asset == rhs.skeleton_asset && lhs.joint_entities == rhs.joint_entities && lhs.clips == rhs.clips;
}
 
inline bool operator!=(const SkeletonAnimationComponent& lhs, const SkeletonAnimationComponent& rhs)
{
    return !(lhs == rhs);
}
 
inline std::string NormalizeSkeletonAnimationClipName(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 NormalizeSkeletonAnimationComponent(SkeletonAnimationComponent& component)
{
    std::unordered_map<std::string, std::size_t> counts;
    for (SkeletonAnimationClipBinding& clip : component.clips)
    {
        std::string normalized_name = NormalizeSkeletonAnimationClipName(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 SkeletonAnimationClipBinding* FindSkeletonAnimationClipBinding(const SkeletonAnimationComponent& component,
                                                                            const std::string_view name)
{
    for (const SkeletonAnimationClipBinding& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline SkeletonAnimationClipBinding* FindSkeletonAnimationClipBinding(SkeletonAnimationComponent& component, const std::string_view name)
{
    for (SkeletonAnimationClipBinding& clip : component.clips)
    {
        if (clip.name == name)
        {
            return &clip;
        }
    }
    return nullptr;
}
 
inline const SkeletonAnimationClipBinding* ResolveActiveSkeletonAnimationClipBinding(const SkeletonAnimationComponent& component,
                                                                                     const AnimationStateComponent* state = nullptr)
{
    if (component.clips.empty())
    {
        return nullptr;
    }
 
    if (state != nullptr && !state->active_clip.empty())
    {
        if (const SkeletonAnimationClipBinding* clip = FindSkeletonAnimationClipBinding(component, state->active_clip))
        {
            return clip;
        }
    }
 
    return &component.clips.front();
}
 
inline Node& operator<<(Node& node, const SkeletonAnimationClipBinding& clip)
{
    node["name"] << clip.name;
    node["clipAsset"] << clip.clip_asset;
    return node;
}
 
inline const Node& operator>>(const Node& node, SkeletonAnimationClipBinding& clip)
{
    if (node.has_property("name"))
    {
        node["name"] >> clip.name;
    }
    else
    {
        clip.name = "Default";
    }
    node["clipAsset"] >> clip.clip_asset;
    return node;
}
 
inline Node& operator<<(Node& node, const SkeletonAnimationComponent& component)
{
    node["skeletonAsset"] << component.skeleton_asset;
    node["jointEntities"] << component.joint_entities;
    node["clips"] << component.clips;
    return node;
}
 
inline const Node& operator>>(const Node& node, SkeletonAnimationComponent& component)
{
    node["skeletonAsset"] >> component.skeleton_asset;
    if (node.has_property("jointEntities"))
    {
        node["jointEntities"] >> component.joint_entities;
    }
    else
    {
        component.joint_entities.clear();
    }
    if (node.has_property("clips"))
    {
        node["clips"] >> component.clips;
    }
    else
    {
        component.clips.clear();
    }
    NormalizeSkeletonAnimationComponent(component);
    return node;
}
} // namespace pixelbullet