AnimLayerMixer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimPose.h"
#include "animation/AnimPoseSource.h"
#include "common/Time.h"
 
#include <string>
#include <vector>
 
namespace eve::animation {
 
class AnimGraph;
class AnimPlayer;
class AnimSkeleton;
class AnimStateMachine;
 
class EVENGINE_API_WORLD AnimBoneMask {
public:
    explicit AnimBoneMask(AnimSkeleton* skeleton);
 
    void setAll(float weight);
    bool setBoneWeight(int boneIndex, float weight);
    bool setBoneWeightByName(const std::string& boneName, float weight);
    bool setBoneAndChildren(const std::string& boneName, float weight);
    float getBoneWeight(int boneIndex) const;
    int getBoneCount() const { return static_cast<int>(weights_.size()); }
    AnimSkeleton* getSkeleton() const { return skeleton_; }
 
private:
    AnimSkeleton*      skeleton_ = nullptr;
    std::vector<float> weights_;
};
 
class EVENGINE_API_WORLD AnimLayerMixer : public IAnimPoseSource {
public:
    explicit AnimLayerMixer(AnimSkeleton* skeleton);
 
    [[nodiscard]] eve::Result<void> setBaseSource(IAnimPoseSource* source);
    bool setBasePlayer(AnimPlayer* player);
    bool setBaseGraph(AnimGraph* graph);
    bool setBaseStateMachine(AnimStateMachine* stateMachine);
    IAnimPoseSource* getBaseSource() const { return baseSource_; }
    AnimPlayer* getBasePlayer() const;
 
    [[nodiscard]] eve::Result<int> addPoseLayer(const std::string& name, IAnimPoseSource* source, AnimBoneMask* mask,
                                                const std::string& mode);
    int addLayer(const std::string& name, AnimPlayer* player, AnimBoneMask* mask, const std::string& mode);
    int addGraphLayer(const std::string& name, AnimGraph* graph, AnimBoneMask* mask, const std::string& mode);
    int addStateMachineLayer(const std::string& name, AnimStateMachine* stateMachine, AnimBoneMask* mask,
                             const std::string& mode);
 
    bool removeLayer(const std::string& name);
    bool setLayerWeight(const std::string& name, float weight);
    bool setLayerEnabled(const std::string& name, bool enabled);
    [[nodiscard]] eve::Result<void> setLayerAdditiveReference(const std::string& name, const std::string& reference);
    bool setLayerAdditiveReferenceCompat(const std::string& name, const std::string& reference);
 
    int getLayerCount() const { return static_cast<int>(layers_.size()); }
    std::string getLayerName(int index) const;
    float getLayerWeight(const std::string& name) const;
    bool getLayerEnabled(const std::string& name) const;
    std::string getLayerMode(const std::string& name) const;
    std::string getLayerAdditiveReference(const std::string& name) const;
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep& step) override;
    void update(float dt);
    AnimPose* getPose() override { return &pose_; }
    AnimSkeleton*                     getSkeleton() const override { return skeleton_; }
    [[nodiscard]] bool                hasCurrentTick() const noexcept override { return hasLastTick_; }
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept override { return lastTick_; }
    [[nodiscard]] int                 getEventCount() const override { return static_cast<int>(events_.size()); }
    [[nodiscard]] std::string         getEventName(int index) const override;
    [[nodiscard]] std::string         getEventPayload(int index) const override;
 
    std::string getEventLayer(int index) const;
    void clearEvents() { events_.clear(); }
 
private:
    struct Layer {
        std::string           name;
        IAnimPoseSource*      source            = nullptr;
        AnimBoneMask*         mask              = nullptr;
        float                 weight            = 1.f;
        bool                  additive          = false;
        bool                  enabled           = true;
        AnimAdditiveReference additiveReference = AnimAdditiveReference::BindPose;
    };
    struct Event {
        std::string layer;
        std::string name;
        std::string payload;
    };
 
    Layer* findLayer(const std::string& name);
    const Layer*                    findLayer(const std::string& name) const;
    void                            collectEvents(const std::string& layerName, IAnimPoseSource* source);
    void                            applyOverride(const Layer& layer);
    void                            applyAdditive(const Layer& layer);
    [[nodiscard]] eve::Result<void> attachSource(IAnimPoseSource* source, const char* role);
    bool                            sourceAlreadyAttached(const IAnimPoseSource* source) const;
 
    AnimSkeleton*      skeleton_   = nullptr;
    IAnimPoseSource*    baseSource_ = nullptr;
    AnimPose           pose_;
    std::vector<Layer> layers_;
    std::vector<Event> events_;
    eve::SimulationTick lastTick_    = eve::SimulationTick::zero();
    bool                hasLastTick_ = false;
 
    void compose();
};
 
}  // namespace eve::animation