MontageCoordinator.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/MontagePlayer.h"
#include "animation/RootMotionPolicy.h"
#include "common/RuntimeHandle.h"
 
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
namespace eve::animation {
 
class AnimBoneMask;
 
struct MontageHandleTag {};
using MontageHandle = RuntimeHandle<MontageHandleTag>;
 
class EVENGINE_API_WORLD MontageCoordinator {
public:
    explicit MontageCoordinator(AnimSkeleton& skeleton);
 
    [[nodiscard]] Result<MontageHandle> play(std::size_t layer, action::ActionTimeline timeline,
                                             std::vector<MontageClipAsset>&& clips,
                                             action::ActionExecutionId executionId, SimulationTick tick);
    [[nodiscard]] Result<std::reference_wrapper<MontagePlayer>> resolve(MontageHandle handle);
    [[nodiscard]] Result<std::reference_wrapper<const MontagePlayer>> resolve(MontageHandle handle) const;
    [[nodiscard]] Result<MontageAdvance> present(MontageHandle handle, const action::ActionAdvance& advance,
                                                 SimulationTick tick);
    [[nodiscard]] Result<void> advanceBlendOuts(Duration delta, SimulationTick tick,
                                                MontageHandle except = MontageHandle::invalid());
    [[nodiscard]] Result<MontageAdvance> stop(MontageHandle handle, Duration blendOut, SimulationTick tick);
    [[nodiscard]] Result<void> setLayerBoneMask(std::size_t layer, std::vector<float> weights);
    [[nodiscard]] Result<void> setLayerBoneMask(std::size_t layer, const AnimBoneMask& mask);
    [[nodiscard]] Result<void> clearLayerBoneMask(std::size_t layer);
    [[nodiscard]] Result<std::vector<float>> layerBoneMask(std::size_t layer) const;
    [[nodiscard]] Result<void> setLayerWeight(std::size_t layer, float weight);
    [[nodiscard]] Result<float> layerWeight(std::size_t layer) const;
    [[nodiscard]] Result<void> setLayerAdditive(std::size_t layer, bool additive);
    [[nodiscard]] Result<bool> layerAdditive(std::size_t layer) const;
    [[nodiscard]] Result<void> setLayerRootMotionReceiver(std::size_t layer,
                                                          IMontageRootMotionReceiver& receiver);
    [[nodiscard]] Result<void> clearLayerRootMotionReceiver(std::size_t layer);
    [[nodiscard]] Result<void> setLayerRootMotionPolicy(std::size_t layer, const RootMotionPolicy& policy);
    [[nodiscard]] Result<void> clearLayerRootMotionPolicy(std::size_t layer);
    [[nodiscard]] Result<std::reference_wrapper<AnimPose>> pose(std::size_t layer);
    [[nodiscard]] Result<std::reference_wrapper<AnimPose>> compose(const AnimPose& basePose);
    void collectFinished() noexcept;
 
private:
    struct Slot {
        std::unique_ptr<MontagePlayer> player;
        MontageHandle::generation_type generation = 1;
        bool                           retired    = false;
    };
    struct Layer {
        Slot                      slots[2];
        std::size_t               active = 1;
        std::unique_ptr<AnimPose> pose;
        std::unique_ptr<AnimPose>   rawPose;
        std::unique_ptr<AnimPose>   blendScratch;
        std::vector<float>        boneMask;
        float                           weight             = 1.0f;
        bool                            additive           = false;
        IMontageRootMotionReceiver*     rootMotionReceiver = nullptr;
        std::optional<RootMotionPolicy> rootMotionPolicy;
    };
 
    [[nodiscard]] static std::size_t handleIndex(std::size_t layer, std::size_t slot) noexcept {
        return layer * 2 + slot;
    }
    [[nodiscard]] Slot* slotFor(MontageHandle handle) noexcept;
    [[nodiscard]] const Slot* slotFor(MontageHandle handle) const noexcept;
    void                      ensureLayer(std::size_t layer);
    void                      retireSlot(Slot& slot) noexcept;
    [[nodiscard]] double      evaluateLayerPose(Layer& layer) const;
 
    AnimSkeleton&      skeleton_;
    std::vector<Layer> layers_;
    std::unique_ptr<AnimPose> composedPose_;
};
 
}  // namespace eve::animation