AnimGraph.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimPose.h"
#include "animation/AnimPoseSource.h"
#include "common/Time.h"
 
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::animation {
 
class AnimClip;
class AnimSkeleton;
 
class EVENGINE_API_WORLD AnimGraph : public IAnimPoseSource {
public:
    explicit AnimGraph(AnimSkeleton* skeleton);
    ~AnimGraph() override = default;
 
    AnimGraph(const AnimGraph&)            = delete;
    AnimGraph& operator=(const AnimGraph&) = delete;
 
    int addClip(AnimClip* clip);
    int addBlend(int a, int b, float weight = 0.5f);
    int addAdditive(int base, int additive, float weight = 1.f);
    int addLayer(int base, int overlay, float weight = 1.f);
    int addOneShot(int base, int shot, float fadeIn = 0.1f, float fadeOut = 0.1f);
    int addBlendSpace1D();
    int addBlendSpace2D();
 
    void addBlendSpace1DPoint(int node, float x, int child);
    void addBlendSpace2DPoint(int node, float x, float y, int child);
    void setBoneMask(int node, int boneIndex, float weight, bool includeChildren = false);
    void clearBoneMask(int node);
 
    void setRoot(int node);
    int  getRoot() const { return root_; }
    int  getNodeCount() const { return static_cast<int>(nodes_.size()); }
    void setWeight(int node, float weight);
    void setPosition1D(int node, float x);
    void setPosition2D(int node, float x, float y);
    void setSpeed(int node, float speed);
    void trigger(int node);
    bool isOneShotActive(int node) const;
 
    [[nodiscard]] eve::Result<void> setAdditiveReference(int node, const std::string& reference);
    bool setAdditiveReferenceCompat(int node, const std::string& reference);
    std::string getAdditiveReference(int node) const;
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep& step) override;
    void update(float dt);
    AnimPose* getPose() override { return &output_; }
    AnimSkeleton*                     getSkeleton() const override { return skeleton_; }
    [[nodiscard]] bool                hasCurrentTick() const noexcept override { return hasLastTick_; }
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept override { return lastTick_; }
 
private:
    enum class Kind { Clip, Blend, Additive, Layer, OneShot, BlendSpace1D, BlendSpace2D };
    struct Point {
        float x = 0.f, y = 0.f;
        int   child = -1;
    };
    struct Node {
        Kind                  kind = Kind::Clip;
        AnimClip*             clip = nullptr;
        int                   a = -1, b = -1;
        float                 weight = 1.f;
        float                 time   = 0.f;
        float                 speed  = 1.f;
        float                 x = 0.f, y = 0.f;
        float                 fadeIn = 0.1f, fadeOut = 0.1f;
        bool                  active            = false;
        AnimAdditiveReference additiveReference = AnimAdditiveReference::Identity;
        std::vector<Point>    points;
        std::vector<float>    mask;
        AnimPose              cache;
        AnimPose              scratch;
        unsigned              cacheGeneration = 0;
    };
 
    int             addNode(Kind kind);
    Node&           requireNode(int node);
    const Node&     requireNode(int node) const;
    void            requireChild(int child) const;
    const AnimPose& evaluate(int node);
    const AnimPose& evaluateBlendSpace(Node& node, bool twoDimensional);
    void            blendMasked(AnimPose& out, const AnimPose& base, const AnimPose& overlay, float weight,
                                const std::vector<float>* mask) const;
    void            applyAdditive(AnimPose& out, const AnimPose& base, const AnimPose& delta, float weight,
                                  const std::vector<float>* mask, AnimAdditiveReference reference) const;
 
    AnimSkeleton*     skeleton_ = nullptr;
    std::vector<Node> nodes_;
    AnimPose          output_;
    int               root_       = -1;
    unsigned          generation_ = 0;
    eve::SimulationTick lastTick_    = eve::SimulationTick::zero();
    bool                hasLastTick_ = false;
 
    void updateUnchecked(float dt);
};
 
}  // namespace eve::animation