animation_graph_types.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
 
#include <glm/vec2.hpp>
 
#include <optional>
#include <string>
#include <vector>
 
namespace pixelbullet
{
enum class AnimationGraphStateKind
{
    Clip,
    Blend1DBySpeed,
};
 
enum class AnimationGraphStatePlaybackMode
{
    Loop,
    OneShot,
};
 
enum class AnimationGraphPatrolMovementMode
{
    Route,
    ChaseTarget,
    InvestigateLastSeenPoint,
};
 
enum class AnimationGraphConditionType
{
    PatrolMovementModeEquals,
    PerceptionDetectedEquals,
    PatrolPausedEquals,
    EffectiveSpeedGreaterOrEqual,
    EffectiveSpeedLessThan,
    CombatAttackActiveEquals,
    CombatRecentlyDamagedEquals,
    CombatDefeatedEquals,
};
 
struct AnimationGraphBlendSample
{
    float speed = 0.0f;
    std::string clip_name;
 
    [[nodiscard]] bool operator==(const AnimationGraphBlendSample&) const noexcept = default;
};
 
struct AnimationGraphStateNotify
{
    std::string notify_id;
    float normalized_time = 0.0f;
 
    [[nodiscard]] bool operator==(const AnimationGraphStateNotify&) const noexcept = default;
};
 
struct AnimationGraphState
{
    std::string id;
    AnimationGraphStateKind kind = AnimationGraphStateKind::Clip;
    AnimationGraphStatePlaybackMode playback_mode = AnimationGraphStatePlaybackMode::Loop;
    std::string clip_name;
    std::vector<AnimationGraphBlendSample> blend_samples;
    std::vector<AnimationGraphStateNotify> notify_markers;
    std::string completion_target_state_id;
 
    [[nodiscard]] bool operator==(const AnimationGraphState&) const noexcept = default;
};
 
struct AnimationGraphCondition
{
    AnimationGraphConditionType type = AnimationGraphConditionType::PatrolMovementModeEquals;
    AnimationGraphPatrolMovementMode patrol_movement_mode = AnimationGraphPatrolMovementMode::Route;
    bool bool_value = false;
    float speed_threshold = 0.0f;
 
    [[nodiscard]] bool operator==(const AnimationGraphCondition&) const noexcept = default;
};
 
struct AnimationGraphTransition
{
    std::string from_state_id;
    std::string target_state_id;
    std::vector<AnimationGraphCondition> conditions;
 
    [[nodiscard]] bool operator==(const AnimationGraphTransition&) const noexcept = default;
};
 
struct AnimationGraphEditorGraphNodeLayout
{
    std::string state_id;
    glm::vec2 position = glm::vec2(0.0f);
 
    [[nodiscard]] bool operator==(const AnimationGraphEditorGraphNodeLayout&) const noexcept = default;
};
 
struct AnimationGraphEditorGraphLayout
{
    std::vector<AnimationGraphEditorGraphNodeLayout> nodes;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return nodes.empty();
    }
 
    [[nodiscard]] bool operator==(const AnimationGraphEditorGraphLayout&) const noexcept = default;
};
 
struct AnimationGraphAsset
{
    std::string initial_state_id;
    std::vector<AnimationGraphState> states;
    std::vector<AnimationGraphTransition> transitions;
    std::optional<AnimationGraphEditorGraphLayout> editor_graph;
 
    [[nodiscard]] bool operator==(const AnimationGraphAsset&) const noexcept = default;
};
} // namespace pixelbullet