AnimPlayer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimPose.h"
#include "animation/AnimPoseSource.h"
#include "animation/RootMotionPolicy.h"
#include "common/Result.h"
#include "common/Time.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::animation {
 
enum class AnimBlendCurve : std::uint8_t {
    Linear,
    EaseInOut,
};
 
class AnimClip;
class AnimSkeleton;
 
class EVENGINE_API_WORLD AnimPlayer : public IAnimPoseSource {
public:
    explicit AnimPlayer(AnimSkeleton* skeleton);
    ~AnimPlayer() override = default;
 
    AnimPlayer(const AnimPlayer&)            = delete;
    AnimPlayer& operator=(const AnimPlayer&) = delete;
 
    AnimSkeleton* getSkeleton() const override { return skeleton_; }
 
    void play(AnimClip* clip);
    void crossFade(AnimClip* clip, float blendSeconds);
    void setBlendCurve(AnimBlendCurve curve) noexcept { blendCurve_ = curve; }
 
    void stop();
    void pause();
    void resume();
 
    void  setSpeed(float speed);
    float getSpeed() const { return speed_; }
    void  setTime(float seconds);
    float getTime() const { return time_; }
    void  setLoop(bool loop) {
        loopOverride_    = loop;
        hasLoopOverride_ = true;
    }
    bool getLoop() const;
 
    bool isPlaying() const { return playing_ && clip_ != nullptr; }
    bool isPaused() const { return paused_; }
 
    AnimClip* getClip() const { return clip_; }
    AnimPose* getPose() override;
    void  setRootMotionBone(int boneIndex);
    int   getRootMotionBone() const { return rootMotionBone_; }
 
    [[nodiscard]] eve::Result<void> setRootMotionPolicy(const RootMotionPolicy& policy);
    [[nodiscard]] RootMotionPolicy getRootMotionPolicy() const { return rootMotionPolicy_; }
    [[nodiscard]] eve::Result<void> setRootMotionCharacterYaw(float yawRadians);
 
    float getRootMotionX() const { return rootMotion_.px; }
    float getRootMotionY() const { return rootMotion_.py; }
    float getRootMotionZ() const { return rootMotion_.pz; }
    float getRootMotionRotationX() const { return rootMotion_.qx; }
    float getRootMotionRotationY() const { return rootMotion_.qy; }
    float getRootMotionRotationZ() const { return rootMotion_.qz; }
    float getRootMotionRotationW() const { return rootMotion_.qw; }
    std::string consumeEvent();
    void  setUpdateRate(float hz);
    float getUpdateRate() const { return updateRate_; }
 
    int getEventCount() const override { return static_cast<int>(events_.size()); }
    std::string getEventName(int index) const override;
    std::string getEventPayload(int index) const override;
    void clearEvents() { events_.clear(); }
 
    [[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);
 
private:
    bool effectiveLoop() const;
    void updateUnchecked(float dt);
 
    AnimSkeleton*            skeleton_ = nullptr;
    AnimClip*                clip_     = nullptr;
    AnimClip*                prevClip_ = nullptr;
    AnimPose                 pose_;
    AnimPose                 prevPose_;
    AnimPose                 sampledPose_;
    AnimPose                 rootPreviousPose_;
    AnimPose                 rootStartPose_;
    AnimPose                 rootEndPose_;
    float                    time_            = 0.f;
    float                    prevTime_        = 0.f;
    float                    speed_           = 1.f;
    float                    blendDuration_   = 0.f;
    float                    blendElapsed_    = 0.f;
    bool                     blending_        = false;
    AnimBlendCurve           blendCurve_      = AnimBlendCurve::Linear;
    bool                     playing_         = false;
    bool                     paused_          = false;
    bool                     hasLoopOverride_ = false;
    bool                     loopOverride_    = true;
    int                      rootMotionBone_  = 0;
    RootMotionPolicy         rootMotionPolicy_{};
    TransformTRS             rootMotion_;
    std::vector<std::string> pendingEvents_;
    float                    updateRate_        = 0.f;
    float                    updateAccumulator_ = 0.f;
    struct DispatchedEvent {
        std::string name;
        std::string payload;
    };
    std::vector<DispatchedEvent> events_;
    eve::SimulationTick          lastTick_    = eve::SimulationTick::zero();
    bool                         hasLastTick_ = false;
 
    void dispatchEvents(float oldTime, float newTime);
};
 
}  // namespace eve::animation