animation_evaluation.h

#pragma once
 
#include "pixelbullet/scene/components/morph_weights_animation_component.h"
#include "pixelbullet/scene/components/skeleton_animation_component.h"
#include "pixelbullet/scene/components/transform_animation_component.h"
#include "pixelbullet/scene/entity_id.h"
 
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
class Filesystem;
class Scene;
 
struct SceneTransformOverrides
{
    std::unordered_map<EntityId::ValueType, Transform> values;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return values.empty();
    }
 
    [[nodiscard]] const Transform* Find(EntityId entity) const noexcept
    {
        if (!entity)
        {
            return nullptr;
        }
 
        const auto it = values.find(entity.Raw());
        return it != values.end() ? &it->second : nullptr;
    }
};
 
class TransformAnimationEvaluator
{
public:
    [[nodiscard]] static SceneTransformOverrides Evaluate(const Scene& scene, float time_seconds);
    [[nodiscard]] static std::optional<Transform> Evaluate(const TransformAnimationComponent& component, float time_seconds);
    [[nodiscard]] static std::optional<Transform> Evaluate(const TransformAnimationComponent& component,
                                                           const AnimationStateComponent* state, float time_seconds);
};
 
class SkeletonAnimationEvaluator
{
public:
    [[nodiscard]] static SceneTransformOverrides Evaluate(const Scene& scene, const Filesystem& filesystem, float time_seconds);
    [[nodiscard]] static std::optional<SceneTransformOverrides> Evaluate(const SkeletonAnimationComponent& component,
                                                                         const Filesystem& filesystem, float time_seconds);
    [[nodiscard]] static std::optional<SceneTransformOverrides> Evaluate(const SkeletonAnimationComponent& component,
                                                                         const Filesystem& filesystem, const AnimationStateComponent* state,
                                                                         float time_seconds);
    [[nodiscard]] static std::optional<SceneTransformOverrides>
    Evaluate(const SkeletonAnimationComponent& component, const Filesystem& filesystem, std::string_view clip_name, float time_seconds);
    [[nodiscard]] static std::optional<std::vector<Transform>> SampleLocalTransforms(const SkeletonAnimationComponent& component,
                                                                                     const Filesystem& filesystem, float time_seconds);
    [[nodiscard]] static std::optional<std::vector<Transform>> SampleLocalTransforms(const SkeletonAnimationComponent& component,
                                                                                     const Filesystem& filesystem,
                                                                                     const AnimationStateComponent* state,
                                                                                     float time_seconds);
    [[nodiscard]] static std::optional<std::vector<Transform>> SampleLocalTransforms(const SkeletonAnimationComponent& component,
                                                                                     const Filesystem& filesystem,
                                                                                     std::string_view clip_name, float time_seconds);
    [[nodiscard]] static std::optional<std::vector<Transform>> SampleRestPoseLocalTransforms(const SkeletonAnimationComponent& component,
                                                                                             const Filesystem& filesystem);
    [[nodiscard]] static float ResolveClipLength(const SkeletonAnimationComponent& component, const Filesystem& filesystem,
                                                 const AnimationStateComponent* state);
    [[nodiscard]] static float ResolveClipLength(const SkeletonAnimationComponent& component, const Filesystem& filesystem,
                                                 std::string_view clip_name);
};
 
enum class LayeredSkeletonPoseBlendMode
{
    Override,
    Additive,
};
 
struct LayeredSkeletonPoseLayer
{
    std::string layer_id;
    LayeredSkeletonPoseBlendMode blend_mode = LayeredSkeletonPoseBlendMode::Override;
    std::vector<std::string> mask_joint_names;
    float layer_weight = 1.0f;
    bool reference_pose = false;
    std::string primary_clip;
    std::optional<std::string> secondary_clip;
    float blend_factor = 0.0f;
    float time_seconds = 0.0f;
};
 
class LayeredSkeletonPoseEvaluator
{
public:
    [[nodiscard]] static std::optional<std::vector<Transform>> EvaluateLocalTransforms(const SkeletonAnimationComponent& component,
                                                                                       const Filesystem& filesystem,
                                                                                       const Scene& joint_name_scene,
                                                                                       const std::vector<LayeredSkeletonPoseLayer>& layers);
};
 
struct SceneMorphWeightOverrides
{
    std::unordered_map<EntityId::ValueType, std::vector<float>> values;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return values.empty();
    }
 
    [[nodiscard]] const std::vector<float>* Find(EntityId entity) const noexcept
    {
        if (!entity)
        {
            return nullptr;
        }
 
        const auto it = values.find(entity.Raw());
        return it != values.end() ? &it->second : nullptr;
    }
};
 
class MorphWeightsAnimationEvaluator
{
public:
    [[nodiscard]] static SceneMorphWeightOverrides Evaluate(const Scene& scene, float time_seconds);
    [[nodiscard]] static std::optional<std::vector<float>> Evaluate(const MorphWeightsAnimationComponent& component, float time_seconds);
    [[nodiscard]] static std::optional<std::vector<float>> Evaluate(const MorphWeightsAnimationComponent& component,
                                                                    const AnimationStateComponent* state, float time_seconds);
};
} // namespace pixelbullet