ControlAnim.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "animation/AnimControlMath.h"
#include "common/Time.h"
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::animation {
 
class EVENGINE_API_WORLD ControlAnim {
public:
    ControlAnim(float frequencyHz = 3.f, float dampingZeta = 1.f, float response = 1.f);
    ~ControlAnim() = default;
 
    ControlAnim(const ControlAnim &)            = delete;
    ControlAnim &operator=(const ControlAnim &) = delete;
 
    void  setFrequency(float frequencyHz);
    float getFrequency() const { return frequencyHz_; }
    void  setDamping(float dampingZeta);
    float getDamping() const { return dampingZeta_; }
    void  setResponse(float response);
    float getResponse() const { return response_; }
 
    void        setIntegrator(const std::string &kind);
    std::string getIntegrator() const;
 
    void set(const std::string &name, float value);
    void setTarget(const std::string &name, float value);
    void setTargetVelocity(const std::string &name, float velocity);
    void impulse(const std::string &name, float deltaVelocity);
 
    bool  has(const std::string &name) const;
    float get(const std::string &name) const;
    float getVelocity(const std::string &name) const;
    float getTarget(const std::string &name) const;
 
    void clear();
    void remove(const std::string &name);
    int  getPropertyCount() const { return static_cast<int>(order_.size()); }
    std::string getPropertyName(int index) const;
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep &step);
    void update(float dt);
 
private:
    enum class Integrator { SecondOrder, Spring, Pd };
 
    struct Channel {
        float y          = 0.f;
        float yd         = 0.f;
        float x          = 0.f;
        float xp         = 0.f;
        float xdExplicit = 0.f;
        bool  hasXd      = false;
        bool  hasPrevX   = false;
    };
 
    void refreshCoeffs();
    Channel &ensure(const std::string &name);
 
    float frequencyHz_  = 3.f;
    float dampingZeta_  = 1.f;
    float response_     = 1.f;
    Integrator integrator_ = Integrator::SecondOrder;
    SecondOrderCoeffs coeffs_{};
    float kp_ = 0.f;
    float kd_ = 0.f;
 
    std::unordered_map<std::string, Channel> channels_;
    std::vector<std::string> order_;
    eve::SimulationTick                      lastTick_    = eve::SimulationTick::zero();
    bool                                     hasLastTick_ = false;
 
    void updateUnchecked(float dt);
};
 
}  // namespace eve::animation