AnimStateMachine.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimPose.h"
#include "animation/AnimPoseSource.h"
#include "common/StateValue.h"
#include "common/Time.h"
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::animation {
 
class AnimClip;
class AnimSkeleton;
 
class EVENGINE_API_WORLD AnimStateMachine : public IAnimPoseSource {
public:
    explicit AnimStateMachine(AnimSkeleton *skeleton);
    ~AnimStateMachine() override;
 
    AnimStateMachine(const AnimStateMachine &)            = delete;
    AnimStateMachine &operator=(const AnimStateMachine &) = delete;
 
    AnimSkeleton *getSkeleton() const override { return skeleton_; }
 
    void addState(const std::string &name, AnimClip *clip);
    void setEntry(const std::string &name);
    bool hasState(const std::string &name) const;
    std::string getCurrentState() const { return currentState_; }
    int getStateCount() const { return static_cast<int>(states_.size()); }
 
    int addTransition(const std::string &from, const std::string &to, float blendSeconds);
 
    void addFloatCondition(int transitionId, const std::string &param, const std::string &op,
                           float threshold);
    void addBoolCondition(int transitionId, const std::string &param, bool value);
    void addTriggerCondition(int transitionId, const std::string &param);
    void setExitTime(int transitionId, float normalizedTime);
    void setHasExitTime(int transitionId, bool enabled);
 
    void setFloat(const std::string &name, float value);
    float getFloat(const std::string &name) const;
    void setBool(const std::string &name, bool value);
    bool getBool(const std::string &name) const;
    void setTrigger(const std::string &name);
    void resetTrigger(const std::string &name);
    bool getTrigger(const std::string& name) const {
        auto it = triggers_.find(name);
        return it != triggers_.end() && it->second;
    }
 
    AnimPose *getPose() override;
    float getStateTime() const { return stateTime_; }
    bool isBlending() const { return blending_; }
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep &step) override;
 
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept override { return lastTick_; }
    [[nodiscard]] bool hasCurrentTick() const noexcept override { return hasLastTick_; }
 
    void update(float dt);
 
    bool captureState(StateValue& out) const;
 
    bool restoreState(const StateValue& in, std::string* err = nullptr);
 
    bool resetToDefaults();
 
private:
    enum class CondKind { Float, Bool, Trigger };
    enum class FloatOp { Gt, Ge, Lt, Le, Eq, Ne };
 
    struct Condition {
        CondKind    kind = CondKind::Float;
        std::string param;
        FloatOp     op        = FloatOp::Gt;
        float       threshold = 0.f;
        bool        boolValue = true;
    };
 
    struct Transition {
        std::string           from;
        std::string           to;
        float                 blendSeconds = 0.2f;
        bool                  hasExitTime  = false;
        float                 exitTime     = 0.f;
        std::vector<Condition> conditions;
    };
 
    struct State {
        std::string name;
        AnimClip   *clip = nullptr;
    };
 
    void        requireState(const std::string &name) const;
    Transition &requireTransition(int id);
    static FloatOp parseFloatOp(const std::string &op);
    bool           conditionsMet(const Transition &tr) const;
    bool           tryTransition();
    void           updateUnchecked(float dt);
 
    AnimSkeleton *skeleton_ = nullptr;
    AnimPose      pose_;
    AnimPose      fromPose_;
    AnimPose      toPose_;
 
    std::unordered_map<std::string, State> states_;
    std::vector<std::string>               stateOrder_;
    std::vector<Transition>                transitions_;
 
    std::unordered_map<std::string, float> floats_;
    std::unordered_map<std::string, bool>  bools_;
    std::unordered_map<std::string, bool>  triggers_;
 
    std::string currentState_;
    std::string nextState_;
    float       stateTime_     = 0.f;
    float       blendDuration_ = 0.f;
    float       blendElapsed_  = 0.f;
    bool        blending_      = false;
    bool        started_       = false;
    eve::SimulationTick lastTick_      = eve::SimulationTick::zero();
    bool                hasLastTick_   = false;
};
 
}  // namespace eve::animation