MontagePlayer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/Action.h"
#include "animation/AnimMath.h"
#include "animation/RootMotionPolicy.h"
#include "common/Result.h"
#include "common/Time.h"
 
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::animation {
 
class AnimClip;
class AnimPlayer;
class AnimPose;
class AnimSkeleton;
 
struct MontageClipAsset {
    std::string               uri;
    std::unique_ptr<AnimClip> clip;
};
 
class IMontageClipProvider {
public:
    virtual ~IMontageClipProvider() = default;
    [[nodiscard]] virtual Result<std::unique_ptr<AnimClip>> load(std::string_view    uri,
                                                                 const AnimSkeleton& skeleton) = 0;
};
 
struct MontageRootMotionMask {
    bool translationX = true;
    bool translationY = true;
    bool translationZ = true;
    bool rotation     = true;
};
 
enum class MontageGapPolicy : std::uint8_t {
    HoldPose,
    BindPose,
};
 
class IMontageRootMotionReceiver {
public:
    virtual ~IMontageRootMotionReceiver() = default;
    virtual void applyMontageRootMotion(const TransformTRS& delta) noexcept = 0;
};
 
using MontageActiveBlock = action::ActionActiveBlock;
 
struct MontageAdvance {
    Duration                                 previous = Duration::zero();
    Duration                                 current  = Duration::zero();
    std::optional<LogicalId>                 sectionId;
    std::vector<action::ActionTimelineEvent> events;
    std::vector<MontageActiveBlock>          activeBlocks;
    TransformTRS                             rootMotion = TransformTRS::identity();
    double                                   weight     = 1.0;
    bool                                     completed  = false;
};
 
class EVENGINE_API_WORLD MontagePlayer {
public:
    explicit MontagePlayer(AnimSkeleton& skeleton);
    ~MontagePlayer();
 
    MontagePlayer(const MontagePlayer&)            = delete;
    MontagePlayer& operator=(const MontagePlayer&) = delete;
 
    [[nodiscard]] Result<void> prepare(action::ActionTimeline timeline, std::vector<MontageClipAsset>&& clips);
    [[nodiscard]] Result<void> prepare(action::ActionTimeline timeline, IMontageClipProvider& provider);
    [[nodiscard]] Result<void> reloadClips(IMontageClipProvider& provider);
    [[nodiscard]] Result<void> setSettings(action::ActionMontageSettings settings);
    [[nodiscard]] Result<void> setSectionSplits(std::vector<Duration> splitTimestamps);
    [[nodiscard]] Result<void> replaceClip(std::string_view uri, std::unique_ptr<AnimClip> clip);
    [[nodiscard]] Result<void> play(action::ActionExecutionId executionId);
    [[nodiscard]] Result<void> rebindExecution(action::ActionExecutionId executionId);
    [[nodiscard]] Result<MontageAdvance> present(const action::ActionAdvance& advance, SimulationTick tick);
    [[nodiscard]] Result<MontageAdvance> jumpToTime(action::ActionExecutionId executionId, Duration target,
                                                    SimulationTick tick);
    [[nodiscard]] Result<MontageAdvance> jumpToSection(action::ActionExecutionId executionId, std::size_t sectionIndex,
                                                       SimulationTick tick);
    [[nodiscard]] Result<MontageAdvance> evaluateSectionProgress(action::ActionExecutionId executionId,
                                                                 std::size_t sectionIndex, double progress,
                                                                 SimulationTick tick);
    [[nodiscard]] Result<std::size_t> physicalSectionIndex() const;
    [[nodiscard]] Result<double> physicalSectionProgress(std::size_t sectionIndex) const;
    [[nodiscard]] Result<MontageAdvance> interrupt(SimulationTick tick);
    [[nodiscard]] Result<MontageAdvance> beginBlendOut(Duration duration, SimulationTick tick);
    [[nodiscard]] Result<MontageAdvance> advanceBlendOut(Duration delta, SimulationTick tick);
    void stop() noexcept;
 
    void setRootMotionReceiver(IMontageRootMotionReceiver& receiver) noexcept { receiver_ = &receiver; }
    void clearRootMotionReceiver() noexcept { receiver_ = nullptr; }
    void setRootMotionMask(MontageRootMotionMask mask) noexcept;
    [[nodiscard]] MontageRootMotionMask getRootMotionMask() const noexcept { return rootMotionMask_; }
    [[nodiscard]] Result<void> setRootMotionPolicy(const RootMotionPolicy& policy);
    [[nodiscard]] RootMotionPolicy getRootMotionPolicy() const noexcept { return rootMotionPolicy_; }
    [[nodiscard]] Result<void> setRootMotionCharacterYaw(float yawRadians);
    void setGapPolicy(MontageGapPolicy policy) noexcept { gapPolicy_ = policy; }
    [[nodiscard]] AnimPose& pose();
    [[nodiscard]] Duration time() const noexcept { return time_; }
    [[nodiscard]] bool isPlaying() const noexcept { return playing_; }
    [[nodiscard]] bool isBlendingOut() const noexcept { return blendingOut_; }
    [[nodiscard]] bool isFinished() const noexcept {
        return timeline_ && !executionId_.isZero() && !playing_ && !blendingOut_ && weight_ > 0.0;
    }
    [[nodiscard]] double weight() const noexcept { return weight_; }
    [[nodiscard]] std::size_t animationLayer() const noexcept {
        return timeline_ ? timeline_->montage.animationLayer : 0U;
    }
    [[nodiscard]] bool footIkEnabled() const noexcept { return timeline_ && timeline_->montage.footIk; }
 
private:
    [[nodiscard]] AnimClip* clipFor(std::string_view uri) const noexcept;
    [[nodiscard]] const action::ActionAnimationSection* sectionAt(Duration time) const noexcept;
    void activate(const action::ActionAnimationSection& section, Duration localTime);
    void accumulateRootMotion(TransformTRS& total) const;
    void applyTimelineRootMotionChannels() noexcept;
    void pushRootMotionPolicyToPlayer() noexcept;
    [[nodiscard]] std::vector<action::ActionTimelineEvent> realignStateEvents(Duration target) const;
    [[nodiscard]] Result<std::vector<MontageActiveBlock>>  activeBlocksAt(Duration target) const;
 
    AnimSkeleton&                         skeleton_;
    std::unique_ptr<AnimPlayer>           player_;
    std::optional<action::ActionTimeline> timeline_;
    std::vector<MontageClipAsset>         clips_;
    const action::ActionAnimationSection* activeSection_ = nullptr;
    IMontageRootMotionReceiver*           receiver_      = nullptr;
    RootMotionPolicy                      rootMotionPolicy_{};
    MontageRootMotionMask                 rootMotionMask_;
    MontageGapPolicy                      gapPolicy_ = MontageGapPolicy::HoldPose;
    action::ActionExecutionId             executionId_{};
    Duration                              time_                = Duration::zero();
    SimulationTick                        lastTick_            = SimulationTick::zero();
    bool                                  hasLastTick_         = false;
    bool                                  started_             = false;
    bool                                  playing_             = false;
    bool                                  blendingOut_         = false;
    Duration                              blendOutDuration_    = Duration::zero();
    Duration                              blendOutElapsed_     = Duration::zero();
    double                                blendOutStartWeight_ = 1.0;
    double                                weight_              = 1.0;
};
 
}  // namespace eve::animation