MotionMatcher.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimPose.h"
#include "common/Time.h"
 
#include <array>
#include <memory>
#include <span>
#include <vector>
 
namespace eve::animation {
 
namespace detail {
struct PoseInertia;
}
class AnimSkeleton;
class MotionDatabase;
struct MotionFeatureTrajectorySample;
struct MotionFeatureCurveSample;
 
struct MotionTransitionBlock {
    float start = 0.f;
    float end = 0.f;
};
struct MotionCostOverride {
    float start = 0.f;
    float end = 0.f;
    float costBias = 0.f;
};
struct MotionSearchRange {
    int   clipIndex          = 0;
    float start              = 0.f;
    float end                = 0.f;
    float costBias           = 0.f;
    bool  disableReselection = false;
    std::vector<MotionTransitionBlock> transitionBlocks;
    float continuingCostBias = 0.f;
    std::vector<MotionCostOverride> costOverrides;
    std::vector<MotionCostOverride> continuingCostOverrides;
};
struct MotionTrajectorySample {
    float x = 0.f, z = 0.f, yaw = 0.f;
};
struct MotionLocomotionSample {
    float x = 0.f, y = 0.f, z = 0.f;
    float vx = 0.f, vy = 0.f, vz = 0.f;
    float yaw = 0.f;
};
 
class EVENGINE_API_WORLD MotionMatcher {
public:
    MotionMatcher(AnimSkeleton* skeleton, MotionDatabase* database);
    ~MotionMatcher();
 
    MotionMatcher(const MotionMatcher&)            = delete;
    MotionMatcher& operator=(const MotionMatcher&) = delete;
 
    AnimSkeleton*   getSkeleton() const { return skeleton_; }
    MotionDatabase* getDatabase() const { return database_; }
 
    void  setDesiredVelocity(float x, float z);
    float getDesiredVelocityX() const { return desiredVelX_; }
    float getDesiredVelocityZ() const { return desiredVelZ_; }
 
    void  setDesiredYaw(float yaw);
    float getDesiredYaw() const { return desiredYaw_; }
 
    void  setSearchInterval(float seconds);
    float getSearchInterval() const { return searchInterval_; }
    void  setBlendTime(float seconds);
    float getBlendTime() const { return blendTime_; }
    [[nodiscard]] eve::Result<void> setPlayRateRange(float minimum, float maximum);
    float getPlayRateMinimum() const { return playRateMin_; }
    float getPlayRateMaximum() const { return playRateMax_; }
    float getPlayRate() const { return playRate_; }
    void  setTrajectoryWeight(float w);
    float getTrajectoryWeight() const { return trajWeight_; }
    void  setPoseWeight(float w);
    float getPoseWeight() const { return poseWeight_; }
    void  setVelocityWeight(float w);
    float getVelocityWeight() const { return velWeight_; }
 
    void setIgnoreRadius(int frames);
    int  getIgnoreRadius() const { return ignoreRadius_; }
    [[nodiscard]] eve::Result<void> setPoseReselectHistory(float seconds);
    float getPoseReselectHistory() const { return poseReselectHistory_; }
 
    int   getMatchedFrame() const { return matchedFrame_; }
    int   getMatchedClipIndex() const;
    float getMatchedTime() const { return matchedTime_; }
    float getLastSearchCost() const { return lastCost_; }
 
    AnimPose* getPose();
 
    [[nodiscard]] eve::Result<int> setCandidateRanges(std::span<const MotionSearchRange> ranges);
    [[nodiscard]] eve::Result<void> setQueryPose(const AnimPose& pose);
    [[nodiscard]] eve::Result<void> setTrajectory(std::span<const MotionTrajectorySample> samples);
 
    [[nodiscard]] eve::Result<void> setLocomotionQuery(const AnimPose& current, const AnimPose& previous,
                                                       float                                   elapsedSeconds,
                                                       std::span<const MotionLocomotionSample> samples);
 
    [[nodiscard]] eve::Result<void> setFeatureQuery(const AnimPose& current, const AnimPose& previous,
                                                    float elapsedSeconds,
                                                    std::span<const MotionFeatureTrajectorySample> samples,
                                                    std::span<const MotionFeatureCurveSample> curves = {});
 
    void search();
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep& step);
    void update(float dt);
 
private:
    void buildSchemaQuery(std::vector<float>& query) const;
    void  buildLocomotionQuery(std::vector<float>& query) const;
    void  buildQuery(std::vector<float>& query) const;
    float cost(const std::vector<float>& query, const std::vector<float>& cand, float upperBound) const;
    void  sampleMatched(AnimPose* out) const;
 
    AnimSkeleton*   skeleton_ = nullptr;
    MotionDatabase* database_ = nullptr;
    AnimPose        pose_;
    std::unique_ptr<detail::PoseInertia> inertia_;
    AnimPose        matchedPose_;
 
    float desiredVelX_ = 0.f;
    float desiredVelZ_ = 0.f;
    float desiredYaw_  = 0.f;
 
    float searchInterval_ = 0.1f;
    float searchTimer_    = 0.f;
    float blendTime_      = 0.15f;
    float blendElapsed_   = 0.f;
    bool  blending_       = false;
    float playRateMin_    = 1.f;
    float playRateMax_    = 1.f;
    float playRate_       = 1.f;
    float queryTrajectorySpeed_ = 0.f;
 
    float trajWeight_   = 1.f;
    float poseWeight_   = 1.f;
    float velWeight_    = 1.f;
    int   ignoreRadius_ = 2;
    float poseReselectHistory_ = 0.f;
    std::vector<std::pair<int, float>> poseHistory_;
 
    int   matchedFrame_ = -1;
    float matchedTime_  = 0.f;
    float lastCost_     = 0.f;
    bool  playing_      = false;
    eve::SimulationTick lastTick_     = eve::SimulationTick::zero();
    bool                hasLastTick_  = false;
 
    std::vector<int>                      candidateFrames_;
    std::vector<float>                    candidateBias_;
    std::vector<float>                    candidateContinuingBias_;
    std::vector<unsigned char>            candidateMask_;
    std::vector<unsigned char>            transitionBlocked_;
    std::vector<unsigned char>            disableReselection_;
    bool                                  filtered_ = false;
    AnimPose                              queryPose_;
    bool                                  hasQueryPose_ = false;
    std::array<MotionTrajectorySample, 3> trajectory_{};
    bool                                  hasTrajectory_ = false;
    AnimPose                              previousQueryPose_;
    float                                 queryPoseInterval_ = 0.f;
    std::array<MotionLocomotionSample, 5> locomotionTrajectory_{};
    bool                                  hasLocomotionQuery_ = false;
    std::vector<float>                     schemaQuery_;
 
    void updateUnchecked(float dt);
    void updatePoseHistory(float dt);
    void updatePlayRate(int frame);
};
 
}  // namespace eve::animation